第一篇博客：Python基础
变量部分——
变量定义：可以变化的量，指事物的状态。
原则：先定义，后使用。
name = "Rachel"
print(name)
垃圾回收机制：
作用：在程序运行过程中，会申请大量的内存空间，若长时间不清理，会影响程序运行效率，垃圾回收机制是pyhon自带的程序。变量名存在堆区，内存地址存在栈区，他们是一种对应关系。
1，引用计数：变量被引用的次数，包括直接引用和间接引用。
2，标记清除：因为有循环引用的存在，会导致内存泄漏的问题。若堆区的值只剩下间接引用，则会被标记为垃圾
3，分代回收：基于引用计数的回收机制，每次回收内存，都需要把所有对象的引用计数都扫描一遍，这是非常耗时的，于是引用分代回收来提高效率，分代回收是以空间换时间的。在多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，会降低扫描频率。
变量命名规则：
1、只能是字母，下划线，数字的组合。
2、不能以数字开头。
3、不能使用关键字。
4、最好简洁，有意义，避免用中文。
两种命名风格：
1、纯小写加下划线。(推荐使用）age_of_Bob = 23
2、驼峰体。AgeOfBob = 23
变量值的三个重要特征
1、id：反映变量值的内存地址，id不同则内存地址不同。 print(id(name))
2、type：不同类型的值用来表示记录不同的状态。 print(type（name）)
3、value：值本身。 print(name)
is和==
is: 表示两边的id是否相同。若a is b ，得到True, 则必有a == b.
==表示两边的值是否相同。若a == b，得到True，则a和b的id可能相同，也可能不同。
若给变量做赋值操作，则id相同
小整数池
范围：-5至256
在Python解释器启动的时候，就设置好了小整数池的范围。
基本数据类型
整型int：表示整数，如年龄，身份证号。age = 16 print(type(age))——int
浮点型float:表示带小数点的数字，如工资。
字符串str：记录描述事物的状态，名字，一段话。字符串之间相加效率低。
列表：存多个值，索引对应值。l = ["张三",23]
字典: key对应值，索引对应key, key 必须是不可变类型。字典中通过key 来取值。d = {name:"张三",age:23}
布尔类型：两种状态，True和False(0和None和空值都是Flase)
与用户交互
用户输入：input 语法会把用户的输入内容存成字符串类型。username = input("请输入你的账号")
在Python2中：raw_input（）的语法与 Python3中的一模一样，Python2中的input()方法规定输入什么类型的数据，就存成什么类型。
用户格式化输出：
1、%(传的值必须与需要的值个数相等，不能多也不能少。兼容性好)
res = "my name is %s,my age is %d" %("Rachel",20)
res = "my name is %(name)s,my age is %(age)d" %("name":"Rachel","age":20) （这一种方法对传值的顺序没有要求）
2、.format方法 （从2.6引用）
res = "my name is{},my age is{}.format("Rachel",20)
res = "my name is{0}{1},my age is {2}{2}{2}".format("Rachel","Nabil",20) （按照标记索引顺序传多个值）
res = "my name is{name},my age is {age}".format("age":20,"name":"Rachel") (对传值顺序没有要求）
3、f (从3.5引用）
x = input("请输入你的名字")
y = input("请输入你的年龄")
res = f"我叫{x},年龄{y}"
print(res)
扩展：
res = f"{10+3}"
print(res) ——13
基本运算符
1、算数运算符（+-*/）
print(10/3) 有小数
print(10//3）只保留整数部分
print(10%3) 取模，取余数
print(10**3) 取10的三次方
2、比较运算符
判断> < = True Flase == !=等
3、赋值运算符
变量赋值：=
增量赋值：age += 1、age *=3、age/=3、age**=3
链式赋值：x = y = z = 10
交叉赋值：m =10 n =20 m,n = n,m
解压赋值：l =[22,33,44,55]
a,b,c,d = l (变量名必须一一对应，不能多不能少）
取前两个变量：a,b,*_ = l
取后两个变量：*_,a,b = l
无法取中间的值，解压字典默认解压出来的是key
4、逻辑运算符
优先级：not>and>or
5、成员运算符
print("be" in "beautiful")——True
*在字典中判断的是key
6、身份运算符
is判断id是否相等
深浅copy
浅拷贝：在复制时一般只复制第一层数据的内存地址，浅拷贝对于除开第一层的数据分开改写无法实现，如下代码，若改写其中一个列表里面第二层数据，则两个列表的第二层数据都会改变。
l = [11,22,[33,44]]
l1 = l.copy()
print(id(l),id(l1)) #1855884452552 1855885924936
l1[2][0] = 55
print(l,l1) #[11, 22, [55, 44]] [11, 22, [55, 44]]
深拷贝：在复制时将每一层数据的内存地址都拷贝过来，所以在改写的时候可以实现两个列表的单独改写。
import copy
l = [11,22,[33,44]]
l1 = copy.deepcopy(l)
print(id(l),id(l1)) #2185047793416 2185047792200
l1[2][0] = 55
print(l,l1) #[11, 22, [33, 44]] [11, 22, [55, 44]]
range函数
range(10)打印的是0--9
顾头不顾尾
可以搭配len()使用
l = [11,34,56,33,22]
for i in range(len(l)):
print(i,l[i])
字符串操作
1、字符串正反向操作：
msg = "hello,python"
print(msg[0])
print(msg[-1])
2、切片：
msg = "hello,python"
res = msg[1:8:2]
print(res) #el,y
print(msg[::-1]) #nohtyp,olleh （可将字符串倒过来写）
*切片，顾头不顾尾，反向切片则要反过来去索引。
3、移除空白：
msg = " my name is Bob "
print(msg.strip()) #my name is Bob (去掉字符串左右两侧的空格）
msg = "###my name is Bob##"
print(msg.strip("#")) #my name is Bob (去掉左右两侧的#，同样也可以去掉*^等符号）
print(msg.lstrip("#")) # my name is Bob## （去掉左边）
print(msg.rstrip("#")) # ###my name is Bob （去掉右边）
4、切分：
msg = "red,blue,yellow,black"
res = msg.split(",",2)
print(res) #['red', 'blue', 'yellow,black'] （可指定切分次数）
print(msg.rsplit(",",1)) # ['red,blue,yellow', 'black'] （也可以从右边开始切）
5、变大、小写：
msg = "sjfFHGJlL"
print(msg.lower()) # sjffhgjll
print(msg.upper()) # SJFFHGJLL
6、以什么开头，结尾：
msg = "reading books"
print(msg.startswith("re")) # True
print(msg.endswith("ks")) # True
7、join拼接：
l = ["22","34","556","622"] 需为字符串
res = ",".join(l)
print(res)
8、replace替换：
msg = "我是张三，张三的张三"
print(msg.replace("张三","王五",2)) # 我是王五，王五的张三 （可以指定替换次数）
9、判断是否是数字：
print("123".isdigit()) # True 需是整数
print("12.3".isdigit()) # False
10、find查找：
msg = "我是谁，我来自哪里"
print(msg.find("我")) # 0 返回要查找的字符串在打字符串里的起始索引
print(msg.find("世界")) # -1 若找不到，返回-1
print(msg.index("世界")) # 若找不到，程序报错
11、count计数：
msg = "我是谁，我来自哪里"
print(msg.count("我")) # 2 返回要查找的字符串在大字符串的出现的次数
12、center、ljust、rjust、zfill
print("张三".center(40,"*")) # *******************张三******************* (居中显示，用*填充至40个字符）
print("张三".ljust(40,"*")) # 张三**************************************(字符串居左显示，用*填充至40个字符）
print("张三".rjust(40,"*")) # **************************************张三(字符串居右显示，用*填充至40个字符）
print("张三".zfill(40,)) # 00000000000000000000000000000000000000张三 (字符串居右显示，用0填充至40个字符）
13、expandtabs设置制表符的空格数
msg = "hello, Bob"
print(msg.expandtabs(3)) # hello, Bob
14、capitalize、swapcase、title
msg = "A beautiful Boy!"
print(msg.capitalize()) # A beautiful boy! （将字符串首字母大写）
print(msg.swapcase()) # a BEAUTIFUL bOY! （将字符串大小写调换)
print(msg.title()) # A Beautiful Boy! (将每个单词首字母大写）
列表操作
增：
l = [22,45,23,21,66]
l1 = [1,2,3]
l.append(566)
print(l) # [22, 45, 23, 21, 66, 566] (在列表后面追加）
l.insert(2,"插队")
print(l) # [22, 45, '插队', 23, 21, 66, 566]（在指定索引前插入值）
l.extend(l1)
print(l) # [22, 45, '插队', 23, 21, 66, 566, 1, 2, 3] (extend方法可以将一个可迭代对象遍历后追加到另一个列表中）
删：
l = [22,45,23,21,66]
del l[1]
print(l) # [22, 23, 21, 66] (根据索引删，若直接del l 则是直接删掉列表l）
l.pop(0)
print(l) # [23, 21, 66] (根据索引删，若无指定索引，默认删除最后一个索引的值。.pop方法删除后返回的值是删掉的值本身）
l.remove(23)
print(l) # [21, 66] (根据指定的值删除，删除后返回None）
.count方法，统计次数，.index查找索引、.reverse倒序、.sort排序、
l = [11,22,33,11,33,11]
print(l.count(11)) # 3 (统计11出现的次数）
print(l.index(22)) # 1 （统计22出现的第一次的索引，若找不到则报错）
l.reverse
print(l) # [11, 22, 33, 11, 33, 11] (将列表倒序）
l.sort()
print(l) # [11, 11, 11, 22, 33, 33] (将列表排序，默认升序）
l.sort(reverse = True)
print(l) # [33, 33, 22, 11, 11, 11] (当设置reverse为True时，则是降序）
集合
集合内元素必须是不可变类型。
集合内元素无序。
集合内元素不能重复。
交集：
l = {11,22,33}
l2 = {22,33,44}
l3 = l&l2
print(l3) # {33, 22} (取交集）
方法二：print(l.intersection(l2)) #{33, 22}
并集：
l = {11,22,33}
l2 = {22,33,44}
l3 = l|l2
print(l3) # {33, 22, 11, 44} (取并集）
方法二：print(l.union(l2)) #{33, 22, 11, 44}
差集：
l = {11,22,33}
l2 = {22,33,44}
l3 = l-l2
print(l3) # {11} (取差集，有先后顺序）
方法二：print(l.difference(l2)) #{11}
对称差集（去掉两者共同的部分）：
l = {11,22,33}
l2 = {22,33,44}
l3 = l^l2
print(l3) # {11, 44} (取对称差集）
方法二：print(l.symmetric_difference(l2)) #{11, 44}
父子集：一方完全包含另一方的元素
l = {11,22,33,44}
l2 = {22,33,44}
print(l>l2) # True
方法二：print(l2.issubset(l)) #True
去重（有局限性）：
只能针对不可变类型，无法保证原来的顺序，
删：
l = {11,22,33,44}
l.discard(11)
print(l) # {33, 44, 22} （若值不在集合中，则不改变集合元素）
l = {11,22,33,44}
l.remove(22)
print(l) # {33, 11, 44} (若删除的值不在集合中，则程序报错）
.update
l = {11,22,33,44}
l2 = {44,66}
l.update(l2)
print(l) # {33, 66, 22, 11, 44} (更新集合）
.pop
l = {11,22,33,44}
l.pop()
print(l) # {11, 44, 22} (随机删除一个值）
.add
l = {11,22,33,44}
l.add(55)
print(l) # {33, 11, 44, 22, 55}
.isdisjoint
l = {11,22,33,44}
l2 = {55,66}
print(l.isdisjoint(l2)) # True (判断两个集合是否有相同元素）