Python笔记

大前提：见名之意
命名规范：字母数字下划线组成，数字不能开头，不能与python关键字重名['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
命名风格：纯小写加下划线、驼峰体

2、赋值符号：把变量值的内存地址绑定给变量名

3、变量值：存储的数据

id是变量值的身份证号反映内存地址
x = 257
y = x # 把变量名x绑定的内存地址再绑定给y，所以id(y)等于id(x)
x = 257
y = 257 # 实际在内存中重新开辟一块空间存放257，所以id(y)不等于id(x)

type类型：

整形int：
浮点型float：
字符串str：
列表list：在[]内用逗号分隔开多个任意类型的元素
元组tuple：在()内用逗号分隔开多个任意类型的元素
字典dict：在{}中按照key:value的格式存放多个元素，其中key是不可变类型，而value可以是任意类型
集合set：在{}内用逗号分隔开多个元素（不可变，无序，唯一）
布尔bool：Ture、False

可变不可变类型：

可变类型（list、dict）：id不变，值可以改变
不可变类型（int、float、str、tuple）：id不变，值固定不可变

4、内存管理机制

引用计数：

当有新的引用指向时，引用计数+1。
当该对象的引用计数失效时，引用计数 -1。
一旦对象的引用计数为0，该对象立即被回收，空间将被释放。

标记清除（引用计数无法解决循环引用）：

标记清除是一种基于追踪回收的算法，分两个阶段。
第一阶段，从根对象出发沿着有向遍历对象，可达的对象标记为“活动对象”，不可达的对象标记为”非活动对象“。
第二阶段，回收那些“非活动对象”。

分代回收（维护引用计数会消耗资源）：

python根据对象的存活时间将内存分为不同的集合，每个集合称为一代，python将内存分为了3代。分别为年轻代(第0代)、中年代(第1代)、老年代(第2代)。
这三代分别对应的是三个链表。
新创建的对象会被分配在年轻代。年轻代链表总数达到上限的时候，python的垃圾回收机制就会触发，把那些可以被回收的对象回收掉，而那些不会回收的对象就会被移到中年代去。以此类推，老年代中的对象是存活时间最久的对象。
分代回收建立在标记清除的技术基础上。

三、用户交互

1、接收输入：

name=input("请输入你的名字：")  
age=input("请输入你的年龄：")        # 将用户输入的所有内容都存成字符串

age=int(age)                       # 将纯数字的字符串转换成整型

2、格式化输出：

2.1、%s

# 根据位置传值，一一对应
res="my name is %s my age is %s" %("cangyuan",18)

# 根据字典的形式传值
res="my name is %(name)s my age is %(age)s" %{"age":18,"name":"cangyuan"}

# 可以接受任意类型
print("my age is %s" %18)
print("my age is %s" %[1,2,3])
print("my age is %s" %{"age":18})

2.2、str.format()

# 根据位置传值，一一对应
res="my name is {} my age is {}".format("cangyuan",18)
res="my name is {0}{0}{0} my age is {1}{1}{1}".format("cangyuan",18)

# 根据key=value传值
res="my name is {name} my age is {age}".format(age=18,name="cangyuan")

print("how","are","you")
print("hello world",end="")

2.3、f

x=input("your name: ")
y=input("your age: ")
res=f"my name is {x} my age is {y}"
print(res)

四、基本运算符

1、算数运算符：+、-、*、/、//、%

2、比较运算符：>、>=、<、<=、==、!=

3、赋值运算符：=

X+=1        #增量赋值

y=x=1       #链式赋值

x=1
y=2
x,y=y,x     #交叉赋值

x,y,z,*_=[111,222,333,444,555]
*_,x,y,z=[111,222,333,444,555]    #解压赋值

4、逻辑运算符：not、and、or

not：逻辑非，使紧随其后的条件取反
and：逻辑与，连接左右两个条件，只有左右两个条件都为真时结果才为真
or：逻辑或，连接左右两个条件，两个条件中有一个为真时结果为真

ps运算的优先级：not > and > or

ps短路运算（了解）：偷懒运算到哪个位置，就把当前位置的值返回

5、成员运算符：in

print("aa" in "hello")        #判断一个字符串是否在一个字符串中
print(22 in [1,22,33,"aa"])   #判断一个元素是否在一个列表中
print("age" in {"age":18})    #判断一个key是否在一个字典中

6、身份运算符：is

x=10
y=12
print(id(x) is id(y))         #比较两个值的id是否相等

五、流程控制

1、if判断

"""
if 条件1：
    代码1
    代码2
    代码3
elif 条件2：
    代码1
    代码2
    代码3
elif 条件3：
    代码1
    代码2
    代码3
...
else:
    代码1
    代码2
    代码3
"""

ps条件：

显示布尔值：True、False

隐式布尔值：所有数据类型，其中0、""、[]、{}、None为假

2、while循环

'''
while 条件:
    代码1
    代码2
    代码3
else:
    代码
'''

break：终止循环，且之后的else不会执行

continue：结束本次循环

3、for循环

'''
for 变量名 in 可迭代对象:        # 字符串、列表、字典、元组、集合
    代码块
else:
    代码块
'''

range()

六、异常处理

# 1、什么是异常
# 程序运行过程中一旦出错就会抛出异常，程序的运行随即终止
# 异常的三个特征(异常的追踪信息、异常的类型、异常的内容)

# 2、为何要处理异常
# 为了增强程序的健壮性
# 即便是程序运行过程中出错了，也不要终止程序
# 而是捕捉异常并处理，将出错信息记录到日志内

# 3、如何处理异常
# 语法上的错误SyntaxError：必须在程序运行前就改正
# 逻辑上的错误
#     错误发生的条件是可以预知的：if
#     错误发生的条件是无法预知的：try

...
print("start=================>>")
try:
    子代码块1
    子代码块2
    子代码块3
except (IndexError,NameError) as e:
    pirnt("异常信息：",e)
except KeyError as e:
    pirnt("异常信息：",e)
except Exception as e：
    print("所有的异常都可以捕捉到")
print("end====================>>")
...

...
print("start=================>>")
try:
    子代码块1
    子代码块2
    子代码块3
except Exception as e：
    print("所有的异常都可以捕捉到")
else:
    print("没有捕捉到异常时执行")
print("end====================>>")
...

...
print("start=================>>")
try:
    子代码块1
    子代码块2
    子代码块3
except Exception as e：
    print("所有的异常都可以捕捉到")
else:
    print("没有异常时执行")
finally：
    print("无论有没有异常都会执行，通常写回收系统资源的代码")
print("end====================>>")
...

七、字符串

1、定义

mes="hello"

2、类型转换

# 任意类型都可以转换成字符串
print(str(1))
print(str(1.2))
print(str([1,2,"cc"]))
print(str((1,2,"cc")))
print(str({"name":"cang","age":18}))

3、内置方法

# 按索引取值（正向取，反向取，只能取不能改）
mes="hello word"
print(mes[0])
print(mes[-1])

# 切片（顾头不顾尾，步长）
mes="hello word"
print(mes[0:5])
print(mes[0:5:2])
print(mes[::-1])

# 长度len
mes="hello word"
print(len(mes))

# 成员运算in，not in
mes="hello word"
print("he" in mes)
print("he" not in mes)

# 循环
mes="how:are:you"
for x in mes:
    print("---->")

mes="**hello world****"
print(mes.strip("*"))           
print(mes.lstrip("*"))
print(mes.rstrip("*"))

mes="hello world"
print(mes.center(20))
print(mes.center(20,"*"))
print(mes.ljust(20,"*"))
print(mes.rjust(20,"*"))

mes="how:are:you"
print(mes.split(":",1))
print(mes.rsplit(":",1))

list1=["how","are","you"]
print(" ".join(list1))

mes="Hello World"
print(mes.lower())
print(mes.upper())
print(mes.startswith("He"))
print(mes.endswith("ld"))

mes="how are you"
print(mes.replace("o","O",2))

mes="123"
print(mes.isdigit())

# find,rfind,index,rindex,count
mes="hello world"
print(mes.find("l"))
print(mes.find("$$$$$"))
print(mes.rfind("l"))        
print(mes.index("l"))
print(mes.rindex("l"))
print(mes.count("l"))

# expendtabs
mes="hello\tworld"
print(mes.expandtabs(2))

# captalize,swapcase,title
mes="hello world"
print(mes.capitalize())
print(mes.swapcase())
print(mes.title())

# is数字系列
num1=b"4"    # bytes
num2="4"     # unicode
num3="四"    # 中文数字
num4="Ⅳ"    # 罗马数字
print(num1.isdigit())       # True
print(num2.isdigit())       # True
print(num3.isdigit())       # False
print(num4.isdigit())       # false
print(num2.isdecimal())     # True
print(num3.isdecimal())     # false
print(num4.isdecimal())     # false
print(num2.isnumeric())     # True
print(num3.isnumeric())     # True
print(num4.isnumeric())     # True

# is其它系列
print("abc".islower())
print("ABC".isupper())
print("ABC".isalpha())
print("ABC221".isalnum())
print("Hello World".istitle())
print("   ".isspace())
print("age_of_earth".isidentifier())

八、列表

1、定义

# 在[]内用逗号分隔开多个任意类型的元素
l=[1,1.2,"aa"]

2、类型转换

# 可迭代对象都可以转换成列表
print(list("aaa"))                        # ["a","a","a"]
print(list((1,2,"cc")))                   # [1,2,"cc"]
print(list({"name":"cang","age":18}))     # ["name","age"]

3、内置方法

# 按索引取值（正向取，反向取，可以取也可以改）
mes=[1,2.2,"hello"]
print(mes[0])
print(mes[-1])
mes[0]=10
print(mes)

# 切片
mes=[1,2.2,"hello"]
print(mes[0:3:1])
print(mes[:])           # 相当于浅拷贝
print(mes[::-1])

# 长度
mes=[1,2.2,"hello"]
print(len(mes))

# 成员运算in，not in
print("hello" in [1,2.2,"hello"])
print("aaa" not in [1,2.2,"hello"])

# 循环
mes=[1,2.2,"hello"]
for x in mes:
    print(x,type(x))

# 增
mes=[1,2.2,"hello"]
mes.append(333)
print(mes)
mes.insert(1,"aaa")
print(mes)
l=[1,2,3]
# for x in l:
#     mes.append(x)
mes.extend(l)
print(mes)

# 删
mes=[1,2.2,"hello"]
del mes[1]
print(mes)
mes=[1,2.2,"hello"]
mes.pop()       # 有返回值，即删除的那个值
print(mes)
mes=[1,2.2,"hello"]
mes.pop(1)
print(mes)
mes=[1,2.2,"hello"]
mes.remove(1)
print(mes)

# 反转、清空、排序
mes=[1,2.2,"hello"]
mes.reverse()
print(mes)
mes.clear()
print(mes)
mes=[1,2.2,-9,30]
mes.sort()
print(mes)
mes=[1,2.2,-9,30]
mes.sort(reverse=True)
print(mes)

# 计数、找到元素所在的索引
mes=[1,2.2,"hello"]
print(mes.count(2.2))
print(mes.index("hello"))    # 找不到则抛出异常

list1=[1,"hello",[111,222]]
list2=list1                    #这不叫拷贝,id(list2)等于id(list1)

list1=[1,"hello",[111,222]]
list2=list1.copy()             
# 浅拷贝，不区分可变不可变类型，直接把地址拿过来
# id(list2)不等于id(list1)
# id(list2[0])等于id(list1[0])
# id(list2[1])等于id(list1[1])
# id(list2[2])等于id(list1[2])

import copy
list1=[1,"hello",[111,222]]
list2=copy.deepcopy(list1)
# 深拷贝，不可变类型直接把地址拿过来，可变类型换个地址
# id(list2)不等于id(list1)
# id(list2[0])等于id(list1[0])
# id(list2[1])等于id(list1[1])
# id(list2[2])不等于id(list1[2])

九、元组

1、定义

# 在()内用逗号分隔开多个任意类型的元素
t=(1,1.3,"aa")        # t=tuple((1,1.3,"aa"))
print(t,type(t))

t=(10,)               # 如果元组中只有一个元素，必须加逗号
print(t,type(t))

t=(10)                # t是整形

2、类型转换

# 可迭代对象都可以转换成元组
print(tuple("aaa"))                        # ("a","a","a")
print(tuple([1,2,"cc"]))                   # (1,2,"cc")
print(tuple({"name":"cang","age":18}))     # ("name","age")

3、内置方法

# 按索引取值（正向取，反向取，只能取不能改）
t=(1,2.2,"aa")
print(t[0])
print(t[-1])

# 切片
t=(1,2.2,"aa")
print(t[0:2])
print(t[::-1])

# 长度
t=(1,2.2,"aa")
print(len(t))

# 成员运算in，not in
t=(1,2.2,"aa")
print(2.2 in t)
print(2.2 not in t)

# 循环
t=(1,2.2,"aa")
for x in t:
    print(x)

# index，count
t=(1,2.2,"aa")
print(t.index(2.2))
print(t.count(2.2))

十、字典

1、定义

# 在{}中按照key:value的格式存放多个值，key是不可变类型，value可以是任意类型
d={"k1":111,"k2":222}
d={}                        # 定义一个空字典
d=dict(k1=111,k2=222)

2、类型转换

info=[
    ["name","cang"],
    ["age",18],
    ["sex","male"]
]

d={}
for k,v in info:
    d[k]=v
print(d)

d=dict(info)
print(d)

key=["name","age","sex"]

d={}
for k in key:
    d[k]=None
print(d)

d={}.fromkeys(key,None)
print(d)

3、内置方法

# 按key取值
d={"k1":111}
d["k1"]=11111     # key存在，则修改
d["k2"]=222       # key不存在，则创建新值

# 长度
d={"k1":333,"k2":222,"k1":222,"k1":111}
print(d,len(d))         # {"k1":111,"k2":222} 2所以key是不可变类型，且唯一

# 成员运算in，not in
d={"k1":333,"k2":222}
print("k1" in d)
print("k3" not in d)

# 键key()、值value()、键值对items()
d={"name":"cang","age":18,"sex":"male"}
print(d.keys())
print(d.values())
print(d.items())

# 循环
d={"name":"cang","age":18,"sex":"male"}
for k in d:
    print(k)
for v in d.values():
    print(v)
for k,v in d.items():
    print(k,v)

d={"name":"cang","age":18,"sex":"male"}
d_new={"name":"yuan","height":888}
# 增
d["k2"]=222                # key不存在，则创建新值；key存在，则修改
d.setdefault("k2",222)     # key不存在，则创建新值；key存在，则do nothing
d.update(d_new)

# 删
del d["name"]
d.pop("age")               # 删除key所对应的value，返回value
d.popitem()                # 随机删
d.clear()

# 查
print(d["age"])
print(d.get("age"))        # 返回key所对应的value，没有返回None

十一、集合

1、定义

# 在{}内用逗号分隔开多个元素（不可变，无序，唯一）
s={1,2.2,"cang",(1,2,3)}
s=set()         # 空集合，注意单独的一个{}代表空集合

2、类型转换

# 可迭代对象可以转换成集合（对象中的元素必须是不可变类型）
s=set("adfhufj")
s=set([1,2,3])
s=set((1,2,3))
s=set({"name":"cang","age":13})
s=set({1,2.2,"cang",(1,2,3)})

3、内置方法

s1={1,2,3}
s2={1,2,4}
# 交集&
print(s1 & s2)
print(s1.intersection(s2))
# 并集|
print(s1 | s2)
print(s1.union(s2))
# 差集-
print(s1 - s2)
print(s1.difference(s2))
print(s2 - s1)
print(s2.difference(s1))
# 对差^
print(s1 ^ s2)
print(s1.symmetric_difference(s2))
# 父子集> < ==
print(s1 > s2)
print(s1.issuperset(s2))
print(s1 < s2)
print(s1.issubset(s2))
print(s1 == s2)

# 增
s1.update(s2)       # 等同于s1 = s1 | s2
s1.add(5)

# 删
s1.pop()
s1.remove(3)        # 删除元素,不存在则报错
s1.discard(5)       # 删除元素,不存在则返回None
s1.clear()