[python]常用语法复习

1. 多行代码

a=1+2\
	+3\
	+4
// a=1+2+3+4

2. 二进制、八进制、十六进制数字

a=0b1001
b=0o1001
c=ox1001

3. 进制转换

a=int("1001",n) #其他进制转十进制,n表示进制 比如n=8表示八进制转换
b=bin(10) #十进制转其他进制 oct()八进制、hex()十六进制,但是输出类型是string

4. 整型之外的基本类型:

• 字符串 “”
• 列表 []
• 元组 ()
• 字典 {key:value,…}
• 集合 {}

5. 字符串运算符(类比所有可迭代类型，列表，元组，集合，字典…)，可读不可写
   

6. 格式化字符串尽量使用format函数，也有另一种3.6之后的方法：f-string

a="i am {name}".format(name="hs")
print(a)

# f-string方式
name="hs" 
a=f"i am {name}" # 变量前加f，自动识别大括号里面的变量替换
print(a)

7. 字符串常用方法
8. 转换为bool类型的时候比如int=0、str="false"的时候才会为false，其他为true

a=bool("0") # true
b=bool(-1) # true

9. unicode默认两字节编码所有；utf-8变长编码，ascii：1字节，中文：3字节…
10. 列表的遍历

a=["!",89,[1,2,3],False]
for i,val in enumerate(a):
    print(i,val,sep="---")
for i in range(len(a)):
    print(a[i])
for val in a:
		print(val)

11. 元组tuple作为可变形参, 字典作为可变形参

def f(*a):
    print(a)
    print(type(a)) # <class 'tuple'>
f(1,2,3,4)

def f(c,**a):
    print(type(a)) # <class 'dict'>
    print(a) # {'k': 3, 'a': 2, 'b': 1}

f(1,k=3,a=2,b=1)

12. 想要在字典dict或者集合set中存储为key，必须可进行hash计算且不可修改，元组可以，列表、字典、集合都不可以作为key；tuple(list)强转list变量
13. bool可以看成是int的子类，默认True=1，False=0。在字典中bool会转成int，True和1是一样的key
14. 运算符/得到的结果类型是float，//得到的是向下取整的int，**是幂运算支持float
15. 坑位：连续赋值导致变量地址一样（python一切皆对象，地址赋值？）

a=b=[1,2,3]
print(id(a)) #
print(id(b)) #

16. if…elif…else

// 赋值
a=10 if 1>2 else 
// 逻辑
if condition:
elif condition:
else

17. 函数指定实参

def f(a,b,c):
    print(a,b,c)

f(c=3,a=2,b=1) #2 1 3

18. 类和对象

class A:
    school = "湘北"
    def __init__(self):
        self.id = 10
    def f(self):
        self.name = "樱木花道"
    @staticmethod
    def f2():
        print("f2")
    @classmethod
    def f3(cls):
		cls.cc = "hs" # 定义了类的属性
        print("f3:{school}".format(school=cls.school))
a = A()
a.age = 10 #结构体外定义实例属性,但是类不可以这么做
# a.f()
print(a.name) #error:需要先执行a.f()
A.f2() #or a.f2() 静态方法默认不会传实例或者类
a.f3() #or a.f2() 会传递类A，才能使用类A内的变量school
print(A.__dict__) #查看类的属性

19. lambda匿名函数

a=lambda x:(2*x,x**2)
print(a(10))

20. 默认都是引用传递，因为一切皆对象
21. ord()函数：获取字符的ascii编码；chr()函数：获取字符assii字符
22. 多维list的初始化方式，python一切皆对象

arr=[[] for _ in range(5)] #这相当于创建了5次
arr2=[[]]*5 #一切皆对象，里面的[]相当于复制了四次，都是一个对象
arr2[0].append(100)
print(arr2) #[[100],[100],[100],[100],[100]] 不满足自己的意图

23. global修饰符

a=111 #归属于文件/包
def f():
    global a #采用global修饰就可以修改函数外部变量了，否则会报错；此外变量a也必须非函数内变量
    a+=1
f()
print(a) #112

24. a,b=b,a方式引发的bug（正确的使用方式尽量让左侧的b与a是不相干的变量，目前看b不受到a的影响即可），比如24. 两两交换链表中的节点

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        res=head
        if head and head.next:
            res=head.next
        pre=None
        while head and head.next:
            if pre:
                pre.next=head.next
				{
					  # 可行方式1
            tmp=head.next
            head.next=tmp.next
            tmp.next=head
					  # 可行方式2
            # head.next.next,  head.next=head,  head.next.next
					  # 错误方式，因为右边计算完毕之后，左边的接收变量是有关系的，
						# 如果head.next先被赋值，那么head.next.next的原来变量也改变了
						# 因为是不会先把左边的真正要赋值的变量先取出来(即先执行next语句)
            # head.next,  head.next.next=head.next.next,  head
				}
            pre=head
            head=head.next

        return res

25. nonlocal
    意义：nonlocal使用能够弥补global和闭包的两个问题。
    对于global，只能使用全局变量，对于嵌套函数中的内层函数而言，无法通过global使用外层函数，通过nonlocal就可以，当然直接读取也可以（闭包）。
    对于闭包，内层函数可以读取外层函数的变量，但是如果在内部函数中尝试进行修改外部变量，且外部变量为不可变类型，则需要在变量前加nonlocal，如果变量为可变类型，则不需要添加nonlocal。

def work():
    x = 0
    def new_work():
        nonlocal x
        x=[123] # 直接把a的类型变了，（a的指向变了）
        return x
    return new_work() # [123]
# 外部变量为可变类型
def f2():
    a = [111] 
    def f():
        nonlocal 
        a[0]=112
    f()

    print(a) # 102
f2()