Python-study

Python-study

jrl Lv3
  2023-02-24 17:10:59 2023-02-24 17:10:59 Created   2023-08-07 19:02:46 2023-08-07 19:02:46 Updated      4.4k Words  17 Mins  

Python学习笔记

(Python教程 - 廖雪峰的官方网站 (liaoxuefeng.com) )

By：jrl

一、Python基础

1.多行注释：

image-20221121161839273

2.变量：

image-20221121162220999

3.除法：

image-20221121163251476

4.Unicode与Utf-8：

image-20221121164752301

Unicode虽然范围广，可以编码汉字，但是占存储空间大，所以转为Utf-8储存。

image-20221122161837329

5.字符编码：

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

image-20221122162404728

image-20221122163630967

文件开头一般写入的注释：

1
2
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

image-20230224154919596

6.格式化字符串的方法：

1）使用占位符

image-20230224160555460

1
2
3
'Age: %s. Gender: %s' % (25, True)

'growth rate: %d %%' % 7   # %%转义字符 表示一个%

2）foramt()

image-20230224165831828

3）f-strng

image-20230224165814292

7.list与tuple

(1)list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

1
2
3
4
5
6
7
8
9
#eg
classmates = ['Michael', 'Bob', 'Tracy']

len(classmates)  #获得list元素的个数
classmates[0]   #用索引来访问list中每一个位置的元素
classmates[-1]  #访问最后一个元素的位置
classmates.append('Adam')  # append() 可以往list中追加元素到末尾
classmates.insert(1, 'Jack')  #也可以把元素插入到指定的位置
classmates.pop()  # pop(i) 删除list末尾的元素

(2)tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改

1
2
3
classmates = ('Michael', 'Bob', 'Tracy')
t = () #或者()  定义空tuple
t=(1,) #定义只有一个元素的tuple

8.条件判断

elif(else if)

1
2
3
4
5
6
7
age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

input()的返回类型是str,str不能直接与整数比较，须转化

1
2
3
4
5
6
s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

9.循环

(1)for in 循环

1
2
3
4
5
6
7
8
9
10
11
#历遍list或者tulpe中的元素
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
    
    
#求和
    sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)

当须历遍的范围过大时，可使用range()函数

1
2
3
4
5
6
list(range(5))    #[0, 1, 2, 3, 4]  0-4

sum = 0
for x in range(101):
    sum = sum + x
print(sum)

(2)while循环

只要条件满足，就不断循环，条件不满足时退出循环

1
2
3
4
5
6
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

break

在循环中，break语句可以提前退出循环

1
2
3
4
5
6
7
n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')

continue

在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

1
2
3
4
5
6
n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

10.dict和set

(1)dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢，给定一个名字，比如'Michael'，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。

1
2
3
4
5
6
7
8
9
10
#初始化
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Adam'] = 67

#查找
d['Michael']

#删除
#要删除一个key，用pop(key)方法，对应的value也会从dict中删除：
 d.pop('Bob')

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉，如果key不存在，dict就会报错要避免key不存在的错误，有两种办法

一是通过in判断key是否存在：

1
'Thomas' in d

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

1
2
d.get('Thomas')
d.get('Thomas', -1)
1
2
要删除一个key，用pop(key)方法，对应的value也会从dict中删除：
 d.pop('Bob')

dict与list比较

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

  1. 查找和插入的速度极快，不会随着key的增加而变慢；
  2. 需要占用大量的内存，内存浪费多。

而list相反：

  1. 查找和插入的时间随着元素的增加而增加；
  2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

(2)set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#要创建一个set，需要提供一个list作为输入集合：
s = set([1, 2, 3])

#注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的     重复元素在set中自动被过滤：
s = set([1, 1, 2, 2, 3, 3])                #  >> s    {1, 2, 3}


#通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：
s.add(4)

#通过remove(key)方法可以删除元素：
s.remove(4)

#set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set与dict比较

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

不可变对象

str是不变对象，而list是可变对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：
a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']


#对于不可变对象，比如str，对str进行操作呢：
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

#replace并不是真的改变了变量a所指向的字符串"abc"，而是创建了一个新的变量b，指向"Abc"

image-20230319191110780

二、函数

1.调用函数

可以通过官网来调查函数： http://docs.python.org/3/library/functions.html#abs

也可以在交互式命令行通过help(),查看函数的帮助信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#eg: 数据类型转换
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

1
2
3
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

2.定义函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

我们以自定义一个求绝对值的my_abs函数为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
    
    
 '''
 请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。
 '''



# 如果你已经把my_abs()的函数定义保存为abstest.py文件了，那么，可以在该文件的当前目录下启动Python解释器，用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）：

交互式环境

image-20230320200608122

(1)空函数

如果想定义一个什么事也不做的空函数，可以用pass语句：

1
2
3
4
5
6
7
8
9
10
def nop():
    pass



# pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
# pass还可以用在其他语句里，比如：

if age >= 18:
    pass

(2)参数检查

调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError：

1
2
3
4
>>> my_abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: my_abs() takes 1 positional argument but 2 were given

但是如果参数类型不对，Python解释器就无法帮我们检查。试试my_abs和内置函数abs的差别：

1
2
3
4
5
6
7
8
9
>>> my_abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in my_abs
TypeError: unorderable types: str() >= int()
>>> abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

当传入了不恰当的参数时，内置函数abs会检查出参数错误，而我们定义的my_abs没有参数检查，会导致if语句出错，出错信息和abs不一样。所以，这个函数定义不够完善。

让我们修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现：

1
2
3
4
5
6
7
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x

添加了参数检查后，如果传入错误的参数类型，函数就可以抛出一个错误：

1
2
3
4
5
>>> my_abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in my_abs
TypeError: bad operand type

(3)关于返回值

Python中的返回值是唯一的

Eg： 在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的坐标：

1
2
3
4
5
6
import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

然后，我们就可以同时获得返回值：

1
2
3
>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0

但其实这只是一种假象，Python函数返回的仍然是单一值：

1
2
3
>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)

原来返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

3.函数的参数

Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

(1)位置参数

我们先写一个计算x2的函数

对于power(x)函数，参数x就是一个位置参数

修改后的power(x, n)函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。

1
2
3
4
5
6
def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

(2)默认参数

新的power(x, n)函数定义没有问题，但是，旧的调用代码失败了，原因是我们增加了一个参数，导致旧的代码因为缺少一个参数而无法正常调用：

1
2
3
4
>>> power(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: power() missing 1 required positional argument: 'n'

这个时候，默认参数就排上用场了。由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：

1
2
3
4
5
6
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

而对于n > 2的其他情况，就必须明确地传入n，比如power(5, 3)。

从上面的例子可以看出，默认参数可以简化函数的调用。设置默认参数时，有几点要注意：

一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；

二是如何设置默认参数。

当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

使用默认参数有什么好处？最大的好处是能降低调用函数的难度。

举个例子，我们写个一年级小学生注册的函数，需要传入name和gender两个参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def enroll(name, gender):
    print('name:', name)
    print('gender:', gender)
   
#如果要继续传入年龄、城市等信息怎么办？这样会使得调用函数的复杂度大大增加。我们可以把年龄和城市设为默认参数，这样，大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数：
def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
    
   #只有与默认参数不符的学生才需要提供额外的信息：
enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')

#也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，其他默认参数继续使用默认值。

默认函数最大的坑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#先定义一个函数，传入一个list，添加一个END再返回：
def add_end(L=[]):
    L.append('END')
    return L

#当你正常调用时，结果似乎不错：
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']

#当你使用默认参数调用时，一开始结果也是对的：
>>> add_end()
['END']

#但是，再次调用add_end()时，结果就不对了：
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

这是因为：

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

定义默认参数要牢记一点：默认参数必须指向不变对象！

1
2
3
4
5
6
7
8
#要修改上面的例子，我们可以用None这个不变对象来实现：
def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

#为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

(3)可变参数

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。

要定义出这个函数，我们必须确定输入的参数。由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：

1
2
3
4
5
6
7
8
9
10
11
def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

#但是调用的时候，需要先组装出一个list或tuple：
>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84

我们把函数的参数改为可变参数：

Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

1
2
3
4
5
6
7
8
9
10
11
12
#调用该函数时，可以传入任意个参数，包括0个参数：
>>> calc(1, 2)
5
>>> calc()
0


def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

(4)关键字参数

  • Title: Python-study
  • Author: jrl
  • Created at: 2023-02-24 17:10:59
  • Updated at: 2023-08-07 19:02:46
  • Link: https://jrl777.github.io/2023/02/24/Python-study/
  • License: This work is licensed under CC BY-NC-SA 4.0.
 Comments
On this page
Python-study
  1. Python学习笔记
  2. (Python教程 - 廖雪峰的官方网站 (liaoxuefeng.com) )
  3. 一、Python基础
    1. 1.多行注释：
    2. 2.变量：
    3. 3.除法：
    4. 4.Unicode与Utf-8：
    5. 5.字符编码：
    6. 6.格式化字符串的方法：
      1. 1）使用占位符
      2. 2）foramt()
    7. 7.list与tuple
      1. (1)list
      2. (2)tuple
    8. 8.条件判断
    9. 9.循环
      1. (1)for in 循环
      2. (2)while循环
    10. 10.dict和set
      1. (1)dict
      2. (2)set
  4. 二、函数
    1. 1.调用函数
    2. 2.定义函数
      1. (1)空函数
      2. (2)参数检查
      3. (3)关于返回值
    3. 3.函数的参数
      1. (1)位置参数
      2. (2)默认参数
      3. (3)可变参数
      4. (4)关键字参数