列表常用方法
#1. append用于在列表末尾追加新的对象
a = [1,2,3]
a.append(4) #the result ： [1, 2, 3, 4]
#2. count方法统计某个元素在列表中出现的次数
a = ['aa','bb','cc','aa','aa']
print(a.count('aa')) #the result ： 3
#3. extend方法可以在列表的末尾一次性追加另一个序列中的多个值
a = [1,2,3]
b = [4,5,6]
a.extend(b) #the result ：[1, 2, 3, 4, 5, 6]
#4. index函数用于从列表中找出某个值第一个匹配项的索引位置
a = [1,2,3,1]
print(a.index(1)) #the result ： 0
#5. insert方法用于将对象插入到列表中
a = [1,2,3]
a.insert(0,'aa') #the result : ['aa', 1, 2, 3]
#6. pop方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值
a = [1,2,3]
a.pop() #the result ： [1, 2]
a.pop(0)
#7. remove方法用于移除列表中某个值的第一个匹配项
a = ['aa','bb','cc','aa']
a.remove('aa') #the result ： ['bb', 'cc', 'aa']
#8. reverse方法将列表中的元素反向存放
a = ['a','b','c']
a.reverse() #the result ： ['c', 'b', 'a']
#9. sort方法用于在原位置对列表进行排序，意味着改变原来的列表，让其中的元素按一定顺序排列
a = ['a','b','c',1,2,3]
a.sort() #the result ：[1, 2, 3, 'a', 'b', 'c']
#10. enumrate
li = [11,22,33]
for k,v in enumerate(li, 1):
print(k,v)
字符串常用方法
#1. find方法可以在一个较长的字符串中查找子串，他返回子串所在位置的最左端索引，如果没有找到则返回-1
a = 'abcdefghijk'
print(a.find('abc')) #the result ： 0
print(a.find('abc',10,100)) #the result ： 11 指定查找的起始和结束查找位置
#2. join方法是非常重要的字符串方法，他是split方法的逆方法，用来连接序列中的元素，并且需要被连接的元素都必须是字符串。
a = ['1','2','3']
print('+'.join(a)) #the result ： 1+2+3
#3. split方法,是一个非常重要的字符串，它是join的逆方法，用来将字符串分割成序列
print('1+2+3+4'.split('+')) #the result ： ['1', '2', '3', '4']
#4. strip 方法返回去除首位空格（不包括内部）的字符串
print(" test test ".strip()) #the result ：“test test”
#5. replace方法返回某字符串所有匹配项均被替换之后得到字符串
print("This is a test".replace('is','is_test')) #the result ： This_test is_test a test
6，查看字符串是以什么为开头 或 结尾
开头：变量名 . startswith（元素）
结尾：变量名 . endswith（元素）
如果正确，输出True，如果错误，输出Fals。
7，字母大小写的转换
全部转大写：变量名 . upper（）
全部转小写：变量名 . lower（）
全部单词首字母大写：变量名 . title（）
第一个单词首字母大写：变量名 . capitalize（）
8，替换
变量名 . replace（”旧值“，”新值“，替换次数）
9，判断字符串的组成
是否全是字母组成：变量名 . isalpha（）
是否全是数字组成：变量名 . isdigit（）
是否是数字和字母：变量名 . isalnum（）
是否全是空格组成：变量名 . isspace（）
是否字母全部是大写：变量名 . isupper（）
是否字母全部是小写：变量名 . islower（）
10，居中
变量名 . center（数字）-------两边对半
字典常用方法
#1. clear方法清除字典中所有的项，这是一个原地操作，所以无返回值（或则说返回None）
d = {'name':"tom"}
d.clear()
print(d) #the result : {}
#2. fromkeys方法使用给定的键建立新的字典，每个键都对应一个默认的值None
print({}.fromkeys(['name','age'])) #the result ： {'age': None, 'name': None}
#3. get方法是个更宽松的访问字典项的方法，如果试图访问字典中不存在的项时不会报错仅会 返回：None
d = {'Tom':8777,'Jack':8888,'Fly':6666}
print(d.get('Tom')) #the result ： 8777
print(d.get('not_exist')) #the result ： None
#4. for循环字典的三种方法
d = {'Tom':8777,'Jack':8888,'Fly':6666}
for k,v in d.items():
print(k,v)
for k in d.values():
print(k)
for k in d.keys():
print(k)
#5. pop方法用于获得对应与给定键的值，然后将这个”键-值”对从字典中移除
d = {'Tom':8777,'Jack':8888,'Fly':6666}
v = d.pop('Tom')
print(v) #8777
#6. setdefault方法在某种程度上类似于get方法，能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值
d = {'Tom':8777,'Jack':8888,'Fly':6666}
d.setdefault('Tom') #the result ： 8777
print(d.setdefault('Test')) #the result ： None
print(d) #{'Fly': 6666, 'Jack': 8888, 'Tom': 8777, 'Test': None}
#7. update方法可以利用一个字典项更新另一个字典，提供的字典中的项会被添加到旧的字典中，如有相同的键则会被覆盖
d = {'Tom':8777,'Jack':8888,'Fly':6666}
a = {'Tom':110,'Test':119}
d.update(a)
print(d) #the result ：{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}
#8. 将两个列表组合成字典
keys = ['a', 'b']
values = [1, 2]
print(dict(zip(keys,values))) # {'a': 1, 'b': 2}
集合常用方法
list_1 = [1,2,3,4,5,1,2]
#1、去重(去除list_1中重复元素1,2)
list_1 = set(list_1) #去重： {1, 2, 3, 4, 5}
print(list_1)
list_2 = set([4,5,6,7,8])
#2、交集（在list_1和list_2中都有的元素4,5）
print(list_1.intersection(list_2)) #交集： {4, 5}
#3、并集（在list_1和list_2中的元素全部打印出来，重复元素仅打印一次）
print(list_1.union(list_2)) #并集： {1, 2, 3, 4, 5, 6, 7, 8}
#4、差集
print(list_1.difference(list_2)) #差集：在list_1中有在list_2中没有： {1, 2, 3}
print(list_2.difference(list_1)) #差集：在list_1中有在list_2中没有： {8, 6, 7}
5，公共方法
+ 拼接 用于字符串，列表，元组
* 复制 用于字符串，列表，元组
in 在 用于字符串，列表，元组，字典
not in 不在 用于字符串，列表，元组，字典
6，内置函数
len（变量） 获取序列的长度
max（变量） 获取最大值
min（变量） 获取最小值
del 变量 删除
元组
1，定义
1，存放的都是按照特定顺序排列组成的序列
2，用（）表示，元素之间用，号连接。
3，元组跟集合一样，存放各种数据类型。
4，元组是不可变的。里面的元素是不可被修改的。
2，创建元组
1，赋值：=
2，空元组：（）
3，数值元组：tuple（range（））
3，删除元组
del 元组名
4，查
1，索引，下标，切片的方式操作。
2，查看元素的下标：index（元素）
3，查看元素出现的次数：count（元素）
4，求和：sum（元组名） ----只能是全部是数字组成的元组。
5，查看元组的长度：len（元组名）
6，元组推导式——会生成一个生成器——查看生成器，用tuple（）强转。
常见数据结构
1. 栈
栈的定义：栈是一种数据集合，可以理解为只能在一端进行插入或删除操作的列表
栈的特点：后进先出（last-in, first-out）
2. 队列定义
- 1、队列是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除
- 2、插入的一端称为队尾（rear），插入动作叫进队或入队
- 3、进行删除的一端称为对头（front），删除动作称为出队
- 4、队列性质：先进先出（First-in, First-out）
- 5、双向队列：队列的两端都允许进行进队和出队操作
3. 链表
链表中每个元素都是一个对象，每个对象称为一个节点，包含有数据域key和指向下一节点的指针next，通过各个节点间的相互连接，最终串联成一个链表
4. 数组
- 所谓数组，就是相同数据类型的元素按一定顺序排列的集合
- 在Java等其他语言中并不是所有的数据都能存储到数组中，只有相同类型的数据才可以一起存储到数组中。
- 因为数组在存储数据时是按顺序存储的，存储数据的内存也是连续的，所以他的特点就是寻址读取数据比较容易，插入和删除比较困难
5. 字典对象实现原理
- 1、哈希表 (hash tables)
- 1.哈希表（也叫散列表），根据关键值对(Key-value)而直接进行访问的数据结构。
- 2.它通过把key和value映射到表中一个位置来访问记录，这种查询速度非常快，更新也快.
- 3.而这个映射函数叫做哈希函数，存放值的数组叫做哈希表。
- 4.通过把每个对象的关键字k作为自变量，通过一个哈希函数h(k)，将k映射到下标h(k)处，并将此对象存储在这个位置。
2、具体操作过程
- 数据添加：把key通过哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。
- 数据查询：再次使用哈希函数将key转换为对应的数组下标，并定位到数组的位置获取value。
3、{“name”:”zhangsan”,”age”:26} 字典如何存储的呢?
- 比如字典{“name”:”zhangsan”,”age”:26}，那么他们的字典key为name、age，假如哈希函数h(“name”)= 1、h(“age”)=3,
- 那么对应字典的key就会存储在列表对应下标的位置，[None, “zhangsan”, None, 26、
4、解决hash冲突
四大高阶函数
1. lambda基本使用
- lambda只是一个表达式，函数体比def简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
- 格式：lambda的一般形式是关键字lambda后面跟一个或多个参数，紧跟一个冒号，之后是一个表达式。
f = lambda x,y,z:x+y+z
print(f(1,2,3)) # 6
my_lambda = lambda arg : arg + 1
print(my_lambda(10)) # 11
- 三元运算
- 三元运算格式： result=值1 if x<y else 值2 if条件成立result=1,否则result=2
- 作用：三元运算，又称三目运算，主要作用是减少代码量，是对简单的条件语句的缩写
name = 'Tom' if 1 == 1 else 'fly'
print(name)
#运行结果： Tom
f = lambda x:x if x % 2 != 0 else x + 100
print(f(10)) # 110
-
filter()函数可以对序列做过滤处理
filter高阶函数
filter（函数，可迭代对象）
把可迭代对象里的每一个元素都放到函数里判断，把满足条件的元素，输出在一个迭代器里。
利用 filter、lambda表达式 获取l1中元素小于33的所有元素 l1 = [11, 22, 33, 44, 55]
l1= [11,22,33,44,55]
a = filter(lambda x: x<33, l1)
print(list(a))
- Map（加工）是对序列根据设定条件进行操作后返回他设置的是操作方法
map（函数，可迭代对象）
把可迭代对象里的每一个元素放到函数里执行，最后输出在一个迭代器里。
利用map，lambda表达式将所有偶数元素加100
l1= [11,22,33,44,55]
ret = map(lambda x:x if x % 2 != 0 else x + 100,l1)
print(list(ret))
#运行结果： [11, 122, 33, 144, 55]
- reduce函数
使用reduce进行求和运算-
reduce()函数即为化简函数，它的执行过程为：每一次迭代，都将上一次的迭代结果与下一个元素一同传入二元func函数中去执行。
-
在reduce()函数中，init是可选的，如果指定，则作为第一次迭代的第一个元素使用，如果没有指定，就取seq中的第一个元素。
-
导包：from functools import reduce
把可迭代对象里的前两个元素放到函数里执行，把结果与第三个元素再放进去执行，最后得到一个值。阶乘，偶数和
-
from functools import reduce
def f(x, y):
return x + y
print(reduce(f, [1, 3, 5, 7, 9])) # 25
#1、先计算头两个元素：f(1, 3)，结果为4；
#2、再把结果和第3个元素计算：f(4, 5)，结果为9；
#3、再把结果和第4个元素计算：f(9, 7)，结果为16；
#4、再把结果和第5个元素计算：f(16, 9)，结果为25；
#5、由于没有更多的元素了，计算结束，返回结果25。
print( reduce(lambda x, y: x + y, [1, 3, 5, 7, 9]) ) # 25
-
sorted函数， 排序
sorted高阶函数
绝对值：正数的绝对是本身，负数的绝对值是相反数
# 如果可迭代对象里的元素都是正数时，可以不用key，默认是升序。
# 如果存在负数时，用了key=abs，会取负数的绝对来排序。
# 最后把结果放在一个列表里。
# sorted(可迭代对象，绝对值，排序)
sorted(Iterable,key=abs,reverse)
sorted对字典排序
d = {'k1':1, 'k3': 3, 'k2':2}
#d.items() = [('k1', 1), ('k3', 3), ('k2', 2)]
a = sorted(d.items(), key=lambda x: x[1])
print(a) # [('k1', 1), ('k2', 2), ('k3', 3)]
捕获异常，抛出异常
1，捕获异常：
try：
错误代码
except 错误的类型：
print（“报错后输出的内容”）
2，捕获异常：
try：
错误代码
except Except as 变量：
print（变量，错误的类里）
else：
print（如果没有错误，输出的内容）
finally：
print（不管是否有错误，都会输出的内容）
3，错误类型
NameError 变量名不存在
TypeError 类型错误
SyntaxError 语法错误
ImportError 导入的模块错误
IndentationError 缩进错误
IoError 输入输出错误
IndexError 索引超出范围错误
AttributeError 属性错误
715
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
