高级语言：
编译型语言执行速度快，不依赖语言环境运行，跨平台差，如C,C++
解释型语言跨平台好，一份代码，到处使用，缺点是执行速度慢，依赖解释器运行，如python,PHP
变量的作用：标记数据，存储数据
变量定义规则：变量名只能是字母，数字或下划线的任意组合。第一个字不能是数字。关键字不能声明为变量。
Python单行注释用 # 单行注释用三对单引号 ''' ''' 。
数据类型：整形int（），浮点型，字符串str()，布尔类型 Ture，False 一般用于逻辑判断
获取一个字符串的地址用 id
字符串：str
一个有序的集合，用于存储和表示基本的文本信息，一对单双或三引号中间包含的内容为字符串。
特性：有序，不可变（一旦声明不可变）
str.swapcase() #将字符串由小写全部转换为大写，由大写全部变成小写。
str.captalize() title() # 首字母大写。
str.upper() #全部变成大写
str.casefold() lower() #全部变成小写
str. center(n) # 以什么为中心。加多少个，什么字符进去。
str.count(n) # 计算出现的次数。
startswith() #判断以什么开始。
endswith(n) #判断以什么结束。
expandtabs(n) # 扩展tabs键，将tabs的长度变长，默认的tabs键长度为8.
find() #查找一个值，并且返回其索引位置，找不到就返回一个负数。
format() 传递，格式化的另外一种方法。
index(n) #返回字符串的索引值，可以 start,end.
isdiggit() #判断是不是一个整数。
join（） #将列表变成字符串之后，以什么来区分每一个列表里的元素。
strip（） #脱掉
split（n）#将字符串分成一个列表。
replace() # 替换
列表：
列表 是一个数据的集合，集合内可以放任何数据类型，可对集合进行方便的增删改查操作
创建 [ ]
查询 .index(), 切片 [_ : _]
n2=["shanshan","tongjie","xiaoyu",1,3,4,4,5,6,7,7,8,8,8,8,0,0,2,3,4,4]
n2[3] #取前面几个值，注意这里是中括号[].
1
>>> n2[-4]#通过索引从列表右边开始取值
2
>>> n2[-2]
4
#取后面几个数的值，可以这样取，那么中间的数就不好去具体数。针对一个列表有很多元素，中间的就不可能进行直接数。那么就引入了 .index（）可以直接根据具体的值来进行索引。找到在列表中的哪一个位置然后再进行调用.
n2.index(8) #先根据值用index()找位置
11
n2[11] #再根据得到的具体位置进行调用，那么中间的数就可以不用去数。
8
#列表里有一个值为8，而用index进行找，就会自动将列表中的第一次出现8的这个值得索引位置给表示出来。就得出8这个值得位置在第11这个地方。
>>> n2.index(4)#4这个值得位置在第5.
5
>>> n2[5] #调用5这个位置的值为4
4
>>> n2[n2.index(4)] # 可以简化成这样的格式，就可以直接调用4这个值。
4 这里需要注意的是如果直接用n2[4]得出的值会是3。
举例说明： n2[n2.index("shanshan")]
'shanshan'
>>> n2[n2.index("xiaoyu")]
'xiaoyu'
>>n2.count(8) # 统计指定元素的个数.count()
4
n2.count("shanshan")#如果是字符串的话必须加引号
1
切片 [ : ]
n2 = ["shanshan","tongjie","xiaoyu",1,3,4,4,5,6,7,7,8,8,8,8,0,0,2,3,4,4]
n2[0:3] #索引0至3的元素，不包括3，顾头不顾尾。
['shanshan', 'tongjie', 'xiaoyu']
n2[ :-1] #索引0至最后一个的值，不包括最后一个值。
['shanshan', 'tongjie', 'xiaoyu', 1, 3, 4, 4, 5, 6, 7, 7, 8, 8, 8, 8, 0, 0, 2, 3, 4]
n2[:] #索引0到最后一个的值相当与复制一个相同的列表
['shanshan', 'tongjie', 'xiaoyu', 1, 3, 4, 4, 5, 6, 7, 7, 8, 8, 8, 8, 0, 0, 2, 3, 4, 4]
n2[3:6]#索引3至6的元素，或者 n2[1:7]
[1, 3, 4] ['tongjie', 'xiaoyu', 1, 3, 4, 4]
例：
n3 = ['shanshan','alibab','xiaouu','xiaojiay','tgy','xyz',7]
n3[ :6:1] #取从0至6的值，但不包括6.间隔为1取一个值。
['shanshan', 'alibab', 'xiaouu', 'xiaojiay', 'tgy', 'xyz']
n3[ 1:6:1] #取从1至6的值，但不包括6.步长为1，间隔为1取一个值。
['alibab', 'xiaouu', 'xiaojiay', 'tgy', 'xyz']
n3[ 1:6:2]#取从1至6的值，但不包括6.步长为2，间隔为2取一个值。,
['alibab', 'xiaojiay', 'xyz']
n3[ 1:6:3] #取从1至6的值，但不包括6.步长为3，间隔为3取一个值
['alibab', 'tgy']
n3[: : 1]#取从头至尾的值.步长为1，间隔为1取一个值即不跳相当于复制一个相同列表
['shanshan', 'alibab', 'xiaouu', 'xiaojiay', 'tgy', 'xyz', 7]
n3[: : 2] #取从头至尾的值.步长为2，间隔为2取一个值。
['shanshan', 'xiaouu', 'tgy', 7]
n3[: : 3] #取从头至尾的值.步长为3，间隔为3取一个值。
['shanshan', 'xiaojiay', 7]
添加/追加 .apped(n) 列表尾部添加
L = ['shanshan', 'xiaoyu', 'zhangsan', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]
>>> L.append("haha")
>>> L
['shanshan', 'xiaoyu', 'zhangsan', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17, 'haha']
插入 任意位置 .insert(position,"value")选择插入的位置，值
L.insert(3,"夏雨荷")
>>> L
['shanshan', 'xiaoyu', 'zhangsan', '夏雨荷', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17, 'haha']
修改 L[position] = "value" 直接把被改的元素位置赋值给要替换的新元素
L = ['shanshan', 'xiaoyu', 'zhangsan', '夏雨荷', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17, 'haha']
>>> L[3] = "dave"
>>> L
['shanshan', 'xiaoyu', 'zhangsan', 'dave', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17, 'haha']
删除 最后一个元素 .pop()
L.pop()
'haha'
>>> L
['shanshan', 'xiaoyu', 'zhangsan', 'dave', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]
删除其中一个元素 .remove（n)
L = ['shanshan', 'xiaoyu', 'zhangsan', 'dave', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]
>>> L.remove("dave")
>>> L
['shanshan', 'xiaoyu', 'zhangsan', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]
删除 全部或者单独元素 del / del 变量名[n]
del L[3]
>>> L
['shanshan', 'xiaoyu', 'zhangsan', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]
>>>
del L
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
L
NameError: name 'L' is not defined #这就表示全部删除了
L = ['shanshan', 'xiaoyu', 'zhangsan', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]
>>> del L[2:4]
>>> L
['shanshan', 'xiaoyu', 3, 7, 4, 5, 9, 11, 17] 利用切片删除
循环 for 变量名 in 变量名 :
把列表里的每一个值取出来赋给 i ,i是一个临时变量。交给print执行下面的语句，依次循环列表里的值。
L2 = ["a","b","c","L","e",1,2]
for you in L2: #这后面一定要有冒号
print(you)
a
b
c
L
e
1
2
举例
range(10)
range(0, 10)
>>> for i in range(10):
print(i)
0
1
2
3
4
5
6
7
8
9
>>> for k in range(10):
print(k)
0
1
2
3
4
5
6
7
8
9
排序 .sort （） 按照askll码值得大小进行排序
n = ["!","*","#","a","b","c","e","y","z"]
n.sort()
>>> n
['!', '#', '*', 'a', 'b', 'c', 'e', 'y', 'z']
.reverse() 原地翻转 倒过来
n.reverse()
>>> n
['z', 'y', 'e', 'c', 'b', 'a', '*', '#', '!']
>>>
拼接 直接 + / n1.extend(n2)
n1 = ["!","*","#","a","b","c","e","y","z"]
n2 = [1,2,4]
n1+n2
['!', '*', '#', 'a', 'b', 'c', 'e', 'y', 'z', 1, 2, 4]
n1.extend(n2)
n1.extend(n2)
>>> n1
['!', '*', '#', 'a', 'b', 'c', 'e', 'y', 'z', 1, 2, 4]
清除 n.clear() 清除了整个列表与del的作用一样但语法不一样
n1 = ["!","*","#","a","b","c","e","y","z"]
>>> n1.clear()
>>> n1
[]
拷贝 n.copy() 这里注意区分 在变量里
n = [3,4,5] a = 7
n4 = n b = a 当b = a时，b的值是指向a的值，并不会因为a的值变化而变化
n a
[3, 4, 5] 7
n4 b
[3, 4, 5] 7
n[2] = "jack" a = 19
n a
[3, 4, 'Jack'] 19
n4 b
[3, 4, 'Jack'] 7
而这里的copy，是复制的意思
所以会根据n的值变化而变化
例题讲解引入 枚举 enumerate
循环names列表，打印每个元素的索引值的元素
names = ["xiaoli","xiaohua","xiaohuang","xiaohei","mali"]
for j in enumerate(names):#注意格式后面加冒号
print(j)
(0, 'xiaoli')
(1, 'xiaohua')
(2, 'xiaohuang')
(3, 'xiaohei')
(4, 'mali') #看输出的结果就把每一个元素和索引值都打印出来了
前面输出的结果里有括号，如何去除括号呢，
names = ["xiaoli","xiaohua","xiaohuang","xiaohei","mali"]
for index, j in enumerate(names):
print(index,j)
0 xiaoli
1 xiaohua
2 xiaohuang
3 xiaohei
4 mali #这样就把括号去除了，是因为前面的 j，只是代表一个变量只能用括号括起来，
而俩个值的话，用逗号即可，也把括号去除掉了
names = ["xiaoli","xiaohua","xiaohuang","xiaohei","mali"]
for a ,j in enumerate(names):
print(a,j)
0 xiaoli
1 xiaohua
2 xiaohuang
3 xiaohei
4 mali #我试了下j前面的变量名其实可以用其他的来代替，不一定非得用index,用index的主要目的是让人明白元素的位置在具体的地方，让人一目了然，因为之前就学了index的作用就是找一个元素的索引值
# 循环names列表，打印每个元素的索引值的元素，当索引值为偶数时，把对应的元素改为-1
names = ["xiaoli","xiaohua","xiaohuang","xiaohei","mali"]
for index,j in enumerate(names): #枚举
if index %2 == 0: #偶数
names[index] = -1#接上一句如果Index的索引值是偶数，就将偶数的值全部重新赋值为-1
print(index,j)
print(names)
0 xiaoli
2 xiaohuang
4 mali
[-1, 'xiaohua', -1, 'xiaohei', -1]
index()返回字符串的索引值，可以start,end
字典:
数据类型-字典
字典一种key -value的数据类型
特性：
key -value结构
key必须可hash且必须为不可变的数据类型，必须唯一（即命名的key名不能重复）
可存放任意多个值，可修改，可以不唯一（value可是任意多个值，且可修改，值可以任意定）
无序
查找速度快
语法：
info = {"n1":["a1","b1","c1","d1","e1","f1","g1"],"n2“:["a2","b2","c2","d2","e2","f2","g2"]}
增加
info["n3"]=["a3","b3","c3","d3","e3","f3","g3"] #后面可以增加很多个或者一个值
>>> info
{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2'], 'n3': ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3']}
>>>
info["n2"][1]+="今天大年初一"#增加某一个值的单项用+=
>>> info["n2"][1]+="今天大年初一"
{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2今天大年初一', 'c2', 'd2', 'e2', 'f2', 'g2'], 'n3': ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3']}
>>>
修改
info["n3"]= "今天要学习"#直接赋值key的n3，value的值就变成“今天要学习”，但却把原先赋值的覆盖了
>>> info
{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2'], 'n3': '今天要学习'}
>>>
查找 in
"n3" in info #判断在不在里边
True
获取 get 如果获取没有的值，print一下就会返回一个none而不是报错。
info.get("n2")
['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2']
>>>
info.get("n7")
>>> print(info.get("n7"))
None#这里没有n7，如果打印出来就会直接返回none
>>>
当然也可以这样，只是要报错，一般不采用
info["n7"]
Traceback (most recent call last):
File "<pyshell#188>", line 1, in <module>
info["n7"]
KeyError: 'n7'
用info. 加上Tab键就可以自动补全，看所有关于字典的关键字，包括删除之类
删除 pop(n)删除一个值同时返回对应的值
info.pop("n3")
['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', '今天要学习', 'hahah ']
popitem()随机删
del info["n2"]#删除其中一个
>>> info
{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n3': ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', '今天要学习', 'hahah ']}
>>> del info#删除全部，注意语法
>>> info
Traceback (most recent call last):
File "<pyshell#250>", line 1, in <module>
info
NameError: name 'info' is not defined
>>>
info.clear()#清除
info.copy()#复制
info.values()#获取打印字典的所有values
info.keys()#获取打印字典所有的key
info.items()#把字典转成一个列表
info={'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2'], 'n3': ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3']}
>>> info.items()
dict_items([('n1', ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1']), ('n2', ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2']), ('n3', ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3'])])
>>>
info.update(n)合并字典，根据key不能命名一样的原则，合并俩个字典时，相同的key值会被覆盖，
info = {"n1":["a1","b1","c1","d1","e1","f1","g1"],"n2:["a2","b2","c2","d2","e2","f2","g2"]}
names = {"xiaoli":[22,"gilr"],"n2":["a2","b2","c2","d2","e2","f2"]}
info.update(names)
>>> info
{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2'], 'xiaoli': [22, 'gilr']}
>>>
>>> info.setdefault(n,n)疑问这样起什么作用
info.setdefault("test","new2")
'new2'
{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2'], 'xiaoli': [22, 'gilr'], 'test': 'new2'}
>>> info.setdefault("test","new2")
'new2'
>>> info
{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2'], 'xiaoli': [22, 'gilr'], 'test': 'new2'}
>>>
info.fromkeys(n,n)#生成一个新的字典
info.fromkeys()#生成一个新的字典key分别为A,B,C，而Value值同为Alex的新字典
info.fromkeys(["A","B","C"],"alex")
{'A': 'alex', 'B': 'alex', 'C': 'alex'}疑问这样起什么作用
多级字典嵌套
字典循环 for in :
info = {"n1":["a1","b1","c1","d1","e1","f1","g1"],"n2":["a2","b2","c2","d2","e2","f2","g2"]}
>>> for k in info:
print(k)#只打印key
n1
n2
for i in info:#这里必须重新for一次
print(k,info[k])#打印key与value的值
n1 ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2']
n2 ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2']
集合
集合是一个无序，不重复的数据组合。
作用：
去重，把一个列表变成集合，就自动去重
关系测试，测试俩组数据之间的交集，差集，并集的关系
特征：
1.确定性（元素必须可hash）
2.互异性（去重）
3.无序性（集合中的元素没有先后之分），如集合{3,4,5}和{3,5,4}算作同一个集合
语法：s = { }#注意是花括号
自动去重功能
s = {1,2,3,5,1,2,4,5,3,7,9,7}
>>> s
{1, 2, 3, 4, 5, 7, 9}
set(n) 或者 n=set(n) #把一个列表，元组转成一个集合，字典不能被转化哦
L =[1,2,3,4,5,2,3]
>>> set(L)#直接定义大括号
{1, 2, 3, 4, 5}
s= (1,2,3,4,5,6,2,4,)
>>> s = set(s)#把s的值传递进去给set,然后直接赋值转化
>>> s
{1, 2, 3, 4, 5, 6}
>>>
.add(n)增加一个值，但不能增加相同的值在集合里去，因为集合有自动去重功能
.pop()删除，随机删除一个值，集合是无序的
.remove(n),删除，指定删除某一个值，如果删除一个没有的值会报错
.discard(n)丢弃，指定删除某一个值，但与remove有区别，如果删除一个没有的值不会报错。
.update()增加，多个值
集合关系测试
intersection 或者 & 交集 指俩个集合都有的共同点和交叉点
difference 或者 - 差集 指俩个集合无共同点的俩边
union 或者 |（管道符）并集 把俩个集合变成一个大集合，并且把重复的去掉
isdisjoint（n） 不相交 判断俩个集合是不是不相交
s = {1, 2, 3, 4, 5, 6}
>>> s1 = {1, 2, 3, 4, }
>>> s.isdisjoint(s1)#判断s 与s1不相交
False#答案为假。是因为s与s1相交
s = {1, 2, 3, 4, 5, 6}
>>> s1={7,8,9,10}
s.isdisjoint(s1)#判断s 与s1不相交
True#答案为真，是因为s与s1确实不相交
>>>
.symmetric_difference(n) 对称差集 指将俩个集合不相交的俩边放在一起
s = {1, 2, 3, 4, 5, 6}
>>> s1 = {1,2,7,8,9,13}
>>> s.symmetric_difference(s1)
{3, 4, 5, 6, 7, 8, 9, 13}#s与s1中不相交的值，放在一起组成一个新的集合
包含关系
.issuperset(n) 判断俩个集合是不是有包含关系，等同于a>=b
.issubset(n) 判断俩个集合是不是有被包含关系，等同于a<=b
s = {3,4,5,6,7}
s1 ={3, 4, 5, 6, 7, 8, 9, 13}
s1.issuperset(s)或者 s1 >= s
True #s1的值全部包含s的值，可理解为s1>=s
反之
s.issuperset(s1)
False #则报错，这就是包含关系
s.issubset(s1)或者s <= s1
True #s 的值被s1全部包含，可理解为s<=s1
>>> s1.issubset(s)
False
其实包含关系，可以理解为，假如A为大，B为小，A>B,A就把B包含进去了，用issuperset,
而B<A,B就必须被包含，顺从于A，用issubset.