Python学习杂记1：基本语法

运算符

取整除法 /
10 // 3 == 3

不转义字符串

常量：r’\n’
变量：

a='\t'
a=a.replace('\t',r'\t')

字符串编码

要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。

>>>'a'.encode('utf-8')
b'a'
>>>'中'.encode('utf-8')    #Unicode->bytes
b'\xe4\xb8\xad'
>>>b'\xe4\xb8\xad'.decode('utf-8') #bytes->Unicode
'中'
>>>b'\xe4\xb8\xad\xff'.decode('utf-8',errors='ignore') #忽略错误的字节
'中'

字符串格式控制

>>>print('%.2f' % 23.1415926)
22.3%

>>>a='Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125);
>>>print(a)
Hello, 小明, 成绩提升了 17.1%

>>>a='小明'
>>>b=17.125
>>>a=f'{a}成绩提升了 {b:.1f}%'
>>>print(a)
小明成绩提升了 17.1%

for循环

>>>l={1,2,3,4,5}
>>>for i in l:
>>>    print(i)

>>>for i in range(3):
>>>    print(i)    
0
1
2

begin=1
end=4   #不包括end
step=2
>>>for i in range(begin:end:step):
>>>    print(i)
1
3

元组、列表、字典、集合

tuple (1,2,3)
list [1,2,3]
字典 {1:'1',2:'2',3:'3'}
set {1,2,3}

不可变对象

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

函数参数

默认参数

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

错误案例：

def add_end(L=[]):
    L.append('END')
    return L

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

改进：

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

可变参数

def func(*args):

func(1, 2)

a=(1,2) 
a=[1,2]
func(*a)

关键字参数

def func(**kw):

>>>func(name='hu',age=18)

>>>kw = {'city': 'Beijing', 'job': 'Engineer'}
>>>func(**kw)

命名关键字参数

命名关键字参数必须传入参数名

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数。

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

命名关键字参数可以有缺省值

def func(*,name='hu',age=12):

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

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

参数定义顺序

参数定义的顺序：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

迭代

判断是否可迭代

>>> from collections.abc import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

>>>for key,value in d.items():
...    print(key,value)

a 1
b 2
c 3

迭代器

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

from collections.abc import Iterator,Iterable # 首先导入模块
>>> isinstance('abc', Iterable)
True
>>> isinstance('abc', Iterator)
False
>>> isinstance(iter('abc'), Iterator)
True

生成式

列表生成式

[表达式+for循环+筛选条件]

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

跟在for后面的if是一个筛选条件，不能带else

if写在for前面必须加else,因为for前面的部分是一个表达式，它必须根据x计算出一个结果。

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

生成器

• 用()生成

>>> g = (x * x for x in range(5))
>>> for n in g: # 用于迭代
...     print(n)
... 
0
1
4
9
16

>>>g = (x * x for x in range(5))
>>>next(g)  # 第一次调用next产生首项
0
>>>next(g)
1

• 用yield生成

generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

def gen(max):
    a = 1
    b = 1
    while a + b < max:
        c=a+b
        a=b
        b=c
        yield c
>>>a=gen(100)
>>>next(a)
2
>>>next(a)
3