第一节—python基础知识

原创于 2021-06-20 11:23:17 发布 · 130 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了Python编程的基础知识，包括字符串处理、编码转换、函数参数、循环及生成器等内容，适合初学者快速掌握Python核心概念。

1、查缺补漏

1、Python允许用r’‘表示’’ "内部的字符串默认不转义。

2、使用\n进行换行不方便的时候，使用

>>> print('''line1
... line2
... line3''')
line1
line2
line3

3、Python提供了ord()：字符转换成编码，chr()函数把编码转换为对应的字符

4、字符串和字节形式

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

x = b'ABC' 是字节型
x ='ABC' 是字符串类型

2、以Unicode表示的str通过encode()方法可以编码为指定的bytes

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

3、把bytes变为str，就需要用decode()方法：

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

正常情况下包含无法解码的字节就会报错，这里可以传入errors='ignore’忽略错误的字节

>>> b'\xe4\xb8\xad\xff'.decode('utf-8')
Traceback (most recent call last):
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 3: invalid start byte

>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
'中'

4、len（）可以计算字符串长度或则字节长度

>>> len('ABC')
3
>>> len('中文')
2

>>> len(b'ABC')
3
>>> len(b'\xe4\xb8\xad\xe6\x96\x87')
6
>>> len('中文'.encode('utf-8'))
6

5、在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

5、函数的参数

1、位置参数：就是传入的参数，按位置顺序赋值给函数。

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n。
2、默认参数：这里就是解决函数的重载问题的，设置一个默认的值。
power（x）用来计算x²，power（x，n）计算x的n次幂。python由于是弱类型语言不支持函数重载，但是可以给n赋予一个默认值。

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

power（5）就是默认调用power（5，2） power（5，3）则是另外一个函数。
切记：默认参数必须放在后面。
切记：默认参数必须指向不变对象。

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']

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

>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

3、可变参数：顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
首先：可以采用传入一个列表或则元组。

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

这时候调用函数必须将参数封装起来，封装成一个列表或则元组。

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84

其次，为了不每次都封装一个元组或则列表，改函数为。

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

这时候的调用方式

>>> calc(1, 2)
5
>>> calc()
0

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

4、关键字参数：就是**kw，这里传入的是一个字典。这里就是一个补录吧，关键字参数没有指定，也可以是一个空字典。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

只有名字和年龄是必选信息，其他的在字典中只是一个补录。

>>> person('Michael', 30)
name: Michael age: 30 other: {}

也可以传入补录信息。

>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

用封装好的字典传入。

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

5、命名关键字参数：在关键字参数中传入的参数名是不受限制的，很可能是完全不必要的。
这里命名关键字参数，就多了个命名，也就是已经确定好需要那些参数了。
首先，可以def person(name, age, *, city, job):在命名关键字参数前面加一个*。

def person(name, age, *, city, job):
    print(name, age, city, job)
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

其次，如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：def person(name, age, *args, city, job):

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

注意：命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。

def person(name, age, *args, city, job):
    print(name, age, args, city, job)
>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given

命名参数可以有缺省值。

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)
>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

6、循环

1、对于字典
对字典的关键字进行循环 for key in d:
对字典的值进行循环for value in d.values()
对字典的关键字和值同时迭代for k, v in d.items()
2、列表生成器
（1）要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

（2）在[]内部书写循环构建复杂的列表

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

（3）for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

（4）还可以在后面构建一个双重循环

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

（5）使用多个变量创建列表

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

（6）把列表中的字母都变成小写的

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

（7）if…else…的应用
在一个列表生成式中，for前面的if … else是表达式，而for后面的if是过滤条件，不能带else。

>>> [x if x % 2 == 0 else -x for x in range(1, 11)]
[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]

7、生成器

1、概念：
列表问题：由于使用列表时候，很可能只使用前面几个元素，但是后面还有一百万个无用数据，太浪费空间了。
解决：用生成器保存算法，用多少提取多少。

>>> g = (x * x for x in range(10))

就是把上面的[]换成()，这样保存的是算法而不是数据本身。
2、输出数据
（1）通过for循环输出

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

（2）通过next（g）输出，按顺序向下输出。

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16

3、yield的概念：相当于return，而且将所在的函数编程生成器，就可以使用next（g）和send（g）函数了。

def foo():
    print("starting...")
    while True:
        res = yield 4
        print("res:",res)
g = foo()
print(next(g))
print("*"*20)
print(next(g))
输出：
starting...
4
********************
res: None
4

1.程序开始执行以后，因为foo函数中有yield关键字，所以foo函数并不会真的执行，而是先得到一个生成器g(相当于一个对象)

2.直到调用next方法，foo函数正式开始执行，先执行foo函数中的print方法，然后进入while循环

3.程序遇到yield关键字，然后把yield想想成return,return了一个4之后，程序停止，**并没有执行赋值给res操作，**此时next(g)语句执行完成，所以输出的前两行（第一个是while上面的print的结果,第二个是return出的结果）是执行print(next(g))的结果，

4.程序执行print("*"20)，输出20个

5.又开始执行下面的print(next(g)),这个时候和上面那个差不多，不过不同的是，这个时候是从刚才那个next程序停止的地方开始执行的，也就是要执行res的赋值操作，这时候要注意，这个时候赋值操作的右边是没有值的（因为刚才那个是return出去了，并没有给赋值操作的左边传参数），所以这个时候res赋值是None,所以接着下面的输出就是res:None,

6.程序会继续在while里执行，又一次碰到yield,这个时候同样return 出4，然后程序停止，print函数输出的4就是这次return出的4.
（来自于https://blog.youkuaiyun.com/mieleizhi0522/article/details/82142856）