Python 4 - 序列和映射
第11节 序列-列表 1
-
一组不同类型的数据组成的数组, 每个位置的元素是可变的
-
创建列表
-
同类型列表
lst_1 = [1, 5, 9, 100]
-
不同类型列表
lst_2 = [1, 5.3, True, [2, 3, 5], "hello"]
-
空列表
lst_3 = [] lst = list()
-
-
列表添加元素
-
末尾每次只能加一个,append(),
lst_3.append("hello world")
-
末尾每次加入多个,extend(),
lst_3.extend([1, 2])
# append list lst = [1, 2, 3] lst.append([4, 5]) # lst 结果为: [1, 2, 3, [4, 5]], i.e., [4, 5] 作为一个元素添加进去
# exten list lst = [1, 2, 3] lst.append([4, 5]) # lst 结果为:[1,2,3,4,5]
-
特定位置加入,insert() 函数,
lst_3.insert(1, "hello")
-
第12节 序列-列表 2
-
访问列表元素
- 通过元素的索引值(从0开始)
print(lst[0])
- 通过元素的索引值(从0开始)
-
修改某个元素的值
- 访问元素然后直接赋新值
lst[0]= new_value
- 访问元素然后直接赋新值
-
列表删除元素
-
remove方法(不需要知道元素的位置,但需要知道元素的值)
-
del语句
-
pop方法(不带参数,取出最后一个元素,返回)(带一个参数,索引值)
lst = ["小A", "小C", "小B", "小D", "小E"] # 1. remove 方法 lst.remove('小A') # 需要知道元素的值 lst.remove("hello") # 会报错 # 安全起见,先判断是否在列表中 if '小A' in lst: lst.remove('小A')
lst = ["小A", "小C", "小B", "小D", "小E"] del lst[0] # 删除 "小A" del lst # 删除整个列表
lst = ["小A", "小C", "小B", "小D", "小E"] name = lst.pop() # name是“小E”, 当前的lst变为["小A", "小C", "小B", "小D"] lst.pop(1) # “小C” 被删除
-
-
列表分片 (一切性获取多个元素)
-
返回一个列表,原列表没有改变
-
取一段:用冒号 [start : end : interval]
lst = [1, 2, 3, 4, 5, 9] lst1 = lst[1:2] # [2] 左比右开去见 lst2 = lst[:3] # [1, 2, 3] lst3 = lst[4:] # [5,9] lst4 = lst[1:5:2] # [2, 4] lst5 = lst[5:1:-2] # [9, 4] lst_copy = lst[:] # [1, 2, 3, 4, 5, 9] lst_reverse = lst[::-1] # [9, 5, 4, 3, 2, 1]
-
第13节 序列-列表 3
-
比较操作符
lst1 = [123, 456] lst2 = [234, 23] lst3 = [123, 456] lst1 > lst2 # 返回False,默认从第一个元素比较
-
逻辑操作符
(lst1 == lst3) and (lst2 > lst1) # 返回True
-
连接操作符
lst4 = lst1 + lst2 # lst4: [123, 456, 234, 23], 相当于extend (最好用extend和append 方法)
-
重复操作符
lst5 = [2, 3] lst5 *= 3 # lst5: [2, 3, 2, 3, 2, 3]
-
成员关系操作符
<元素 in 列表> # 返回 True / False 123 not in lst1 # 返回 False
-
列表相关函数
-
dir(list) 查看所有相关的函数
-
count 计算某个元素在列表中出现的次数
-
index 返回某个值第一个出现的位置
lst = [1, 2, 3, 1, 2, 1, 1] lst.count(2) # 返回2 lst.index(2) # 返回1 lst.index(1, 2, 5) # 从2-5中 寻找第一次出现1的位置
-
reverse函数,把列表反转(没有返回值,直接把原来列表翻转)
-
sort 函数, 把原列表排序(直接把原来列表反转)
lst = [4, 5, 2, 1, 3] lst.sort() # lst变成 [1,2,3,4,5] 默认从小到达排序 lst = [4, 5, 2, 1, 3] lst.sort(func,key,reverse=True)
-
len 返回长度
-
max 返回最大值
-
min 返回最小值
-
-
python中的软copy和硬copy
-
因为变量名只是一个标签,用变量给变量赋值,其实对象仍旧只有一个,类似java的引用类型,因为python中一切都是对象,所以这都是软copy
lst = [4, 5, 2, 1, 3] lst1 = lst[:] # hard copy lst2 = lst # soft copy lst.sort() # lst:[1,2,3,4,5], lst2:[1,2,3,4,5], lst1: [4, 5, 2, 1, 3]
-
第14节 序列-元组
-
元组:带上了枷锁的列表,元素可以是不同类型,但是元素确定后不可以改变
-
推论:元组是不能删除tuple中的元素,不能排序,不能在tuple中间位置插入新的数据
-
应用:函数的形参,函数的返回值
-
创建元组 (关键是逗号)
# 列表用[],元组用() tp1 = (1, 2, 3, 4, 5) tp1 = 1, 2, 3, 5, 9 # 空元祖 tp2 = () tp3 = tuple() # 只有一个元素的元组 tp4 = (1,) # 不加逗号,就是整形了。。 tp5 = 1,
-
访问元组
#same to list, using index to access the date print(tp1[0]) # 同样有slicing print(tp1[1:]) print(tp1[::-1]) print(tp1[:]) # 元组是不能被修改的 tp2[0] = 5 ## 会报错
-
更新元组
# 就像字符串一样,其实不是更新,是创建了新的数据 temp = "小A", "小B", "小D", "小E" new_t = temp[:2] + ("小C", ) + temp[2:]
-
删除元组
# 删除整个元组 del temp #很少用,因为静态的变量,在失去变量名(引用)后,会被垃圾回收机制处理掉 # 删除元组中某个元素---not allowed
-
元组相关的操作符
- 拼接:+
- 重复: *
- 成员: in, not in
- 关系: >, >=, <, <=, ==, !=
- 逻辑: and or not
-
相关函数
- len, max, min
第15节 序列-字符串相关函数
-
创建字符串
# python没有单独的字符 str1 = "hey, how are u?"
-
访问字符串
print(str1[2]) # 输出y print(str1[:3]) # 输出hey
-
修改字符串
# 跟元组一样,string也是不能修改的,只能创建新的字符串 str2 = str1[:3] + "no" + str1[3:]
-
各种操作符,跟列表和元组一样,都支持的
-
各种字符串相关的函数
- 大小写,空格转换相关
- str1.capitalized(), 把字符串的第一个字符改为大写
- str1.casefold(), 把整个字符串的所有字符改为小写
- str1.expandtab([tabsize=8]), 把字符串中的tab符号转换为空格,或者指定长度
- str1.swapcase(),反转字符串中的大小写
- str1.title(), 返回标题化的字符串(所有单词都是以大写开始,其余字符均是小写)
- str1.translate(table),根据table的规则(可以由str.maketrans(‘a’,’b’)定制)转换字符串中的字符
- str1.lower(), 转换字符串中所有大写字符为小写
- str1.upper(),转换字符串中所有小写字符为大写
- 判断字符串包含什么类型数据
- isalnum(), 如果字符串至少有一个字符, 并且所有字符都是字母或者数字,返回True,否则False
- isalpha(), 如果字符串至少有一个字符, 并且所有字符都是字母,返回True,否则False
- isdecimal(), 如果字符串只包含十进制数字则返回True,否则False
- isdigit(), 如果字符串只包含数字则返回True,否则False
- isnumeric(),如果字符串中只包含数字字符,则返回True,否则False
- isspace(),如果字符串中只包含空格,则返回True
- istitle(),如果字符串是标题化(每个单词以大写开头)的,返回True
- islower(),如果字符串中至少包含一个区分大小写的字符,并且这些字符都是小写,返回True
- isupper(),如果字符串中至少包含一个区分大小写的字符,并且这些字符都是大写,返回True
- 与子字符串相关的操作
- str1.count(sub[,start[,end]]) 返回sub子串在字符串里出现的次数,start/end 表示范围
- str1.endswith(sub[,start[,end]]), 检查字符是否以sub子串结束,返回True/False
- str1.startswidth(prefix[,start[,end]]),检查字符串是否以prefix开头,返回True/False
- str1.find(sub[,start[,end]]) , 检查字符串中是否包含sub,如果有,返回索引值,否则返回-1
- st1.rfind(sub[,start[,end]]) , 类似find, 只是从右边开始找
- str1.index(sub[,start[,end]]), 跟find方法一样,但是如果sub不再string中会产生异常
- str1.rindex(sub[,start[,end]]) , 同index方法,从右边开始找
- 字符串拼接, 拆解, 替换, 删除等等
- str1.join(sub),以str1作为分隔符,插入到sub中所有的字符之间
- str1.partition(sub),在str1中找到sub,把字符串分成三个字符的元组(pre_sub, sub, fol_sub),如果字符串中不包含sub,则返回(‘原字符串’,’’, ‘’)
- str1.rpartition(sub),类似partition方法,只是从右边开始查找
- str1.replace(old, new[,count]),把字符串中的old子字符串换乘new字符串,如果指定count,则替换次数不能超过count
- str1.strip([chars]), 删除字符串前面和后面所有的空格,chars可以指定要删除的字符
- str1.lstrip(),删除字符串左边所有的空格。
- str1.rstrip(), 删除字符串末尾的空格。
- str1.split(sep=None, maxsplit=-1),不带参数默认是以空格为分隔符切片字符串,如果有设置maxsplit参数,则仅分割maxsplit个子字符串,返回切片后的子字符串拼接的列表
- str1.splitlines(([keepends])),按照’\n’分割,返回一个包含各行作为元素的列表,如果指定keepends参数,则返回前keepends行。
- 其它
- str1.center(width), 将字符串居中,并使用空格填充至长度width的新字符串(文本的居中)
- str1.zfill(width), 返回长度为width的字符串,原字符串右对齐,前面用0填充.(对数值型字符串)
- str1.encode(encoding=’utf-8’, errors=’strict’) 以encoding指定的编码格式对字符串编码
- str1.ljust(width), 返回一个左对齐的字符串,并使用空格填充至长度为width的新字符串
- str1.rjust(width), 返回一个右对齐的字符串,并使用空格填充至长度为width的新字符串
- 大小写,空格转换相关
第16节 序列-字符串格式化
-
format函数,接受两种参数:位置参数,关键字参数
# 1. 两种方式 {x} 表示 replacement(替换域) # 位置参数 "{0} wanna travel to {1}.{2}".format("Zhen", "China", "Shanghai") # 关键字参数 "{a} wanna travel to {b}.{c}".format(a="Zhen", b="China", c="Shanghai") # 综合两种参数 (位置参数必须在关键字参数之前) "{0} wanna travel to {b}.{c}".format("Zhen", b="China", c="Shanghai") # 打印花括号 "0".format("nothing") # 输出结果为‘{0}’
-
格式化符号
Sign Meaning %c
格式化字符及其ASCII %s
格式化字符串 %d
格式化整数 %o
格式化无符号八进制数 %x
格式化无符号十六进制数 %X
格式化无符号十六进制数(大写) %f
格式化浮点数 %e
用科学计数法格式化服点数(显示e) %E
用科学计数法格式化服点数(显示E) %g
根据值的大小,决定使用 %f 或者%e %G
根据值的大小,决定使用 %f 或者%E -
格式化符号辅助
Symbol Meaning m.n m是显示的最小总宽度(可选),n是小数点后的位数 - 用于左对齐 + 在正数前面显示加号 # 在八进制数前面显示’0o’, 在十六进制数前面显示’0x’ or ‘0X’ 0 显示的数字前面填充‘0’,取代空格 # 2. format数字, 在替换域{}中,冒号表示格式化符号的开始 # 小数点位数 '{0:.2f}'.format(123.2279) '{0:.2e}'.format(123.2279) '{0:.2E}'.format(123.2279) '{0:.2g}'.format(123.2279)
-
旧的形式用
%
代替format函数'%c' % 97 '%c %c %c' % (97, 98, 99)
第17节 序列-序列总结
-
列表,元组和字符串的共同点
- 都可以通过索引得到每一个元素
- 默认索引都是从0开始
- 可以通过分片的方法得到一个范围内的元素的集合(包括硬copy和翻转)
- 有很多共同的操作符(重复操作符***,拼接操作符+,成员关系操作符in,not in**,比较操作符, 逻辑操作符)
-
一些常用的builtin functions
-
list([iterable]), 把一个可迭代对象转换为列表
-
tuple([iterable]), 把一个可迭代对象转换为元组
-
str(obj),把obj对象转换为字符串
-
len(), 返回序列的长度
-
max(), 返回序列中的最大值, 必须保证数据是同一类型
-
min(), 返回序列中的最小值
-
sum(iterable[,start=0]), 返回序列iterable和可选参数start的总和
-
sorted([list]), 不改变list本身(与list.sort()不同),返回一个新的拍好序的list
-
reversed([list]), 不改变lst本身(与list.reverse()不同),返回一个倒序的迭代器对象(可以list(reversed(lst1)))
-
enumerate(), 生成由每个元素的index值和item值组成的元组
-
zip(), 返回由各个参数序列组成的元组
nums = [1, 1, 2, 3, 5, 8, 13] list(enumerate(nums)) # [(0, 1), (1, 1), (2, 2), (3, 3), (4, 5), (5, 8), (6, 13)] a = [3, 2, 5, 7, 9] b = [1, 2, 17, 6, 22, 11, 90] list(zip(a, b)) # [(3, 1), (2, 2), (5, 17), (7, 6), (9, 22)]
-
第18节 映射-字典 1
-
键值对(key,value)
-
字典中的元素是无序的
-
创建字典
# 1.1 直接用{}和冒号: dict1 = {'李宁':"一切皆有可能", 'Nike':"Just do it", "Addidas":"Nothing is impossible"} print("The slogon of Niki is ", dict1["Nike"]) # 1.2 key 可以是字符串,可以是整形或者浮点型 dict2 = {1:'one', 2:'two', 3:'three'} # 2.1 用dict函数,元组和列表创建字典 dict4 = dict( ( (1.1, 'z'), (1.2, 'h'), (1.3, 'e'), (1.4, 'n') ) ) #{1.1: 'z', 1.2: 'h', 1.3: 'e', 1.4: 'n'} # 2.2 通过关键字形式 dict5 = dict(你好="hello", 早上好="good morning", night="good night") # {'night': 'good night', '你好': 'hello', '早上好': 'good morning'} # 3. 空的字典 dict3 = {} dict3 = dict() # 4. 通过访问 dict5['电脑']='computer' #如果key存在,则是改写,如果不存在,则是插入key-value pair
-
访问字典
dict[key]
访问值
第19节 映射-字典 2
-
常用的一些函数
- fromkeys(S[,v]), new dict with keys from S and values equal to v (v defaults to None)
# fromkeys, 创造一个新的字典 dict1 = {} dict1.fromkeys((1, 2, 3)) #{ 1: None, 2: None, 3: None} dict1.fromkeys((1,2,3), "hello") # {1: 'hello', 2: 'hello', 3: 'hello'} dict1.fromkeys((1,2,3), ("one", "two", "three")) #{1: ('one', 'two', 'three'), # 2: ('one', 'two', 'three'), # 3: ('one', 'two', 'three')}
- 访问字典之 keys(), values(), items()
dict2 = {} dict2 = dict2.fromkeys(range(5), "hello") list(dict2.keys()) # [0, 1, 2, 3, 4] list(dict2.values()) #['hello', # 'hello', # 'hello', # 'hello', # 'hello'] list(dict2.items()) # dict_items([(0, 'hello'), (1, 'hello'), (2, 'hello'), (3, 'hello'), (4, 'hello'), (5, 'hello'), (6, 'hello'), (7, 'hello'), (8, 'hello'), (9, 'hello')])
- 安全访问get(key)
dict3={1:'one', 2:'two'} # 直接访问, --- 3 不是key print(dict3[3]) # 出错, keyError # 安全访问 print(dict3.get(3)) # None print(dict3.get(3, 'number')) # 设置默认值
-
判断一个键(key)是否在字典中 (成员关系操作符: in, not in)
-
清空字典, clear()
# 通过 ={} 来清空字符串,是有风险的 dict_a = {'姓名':"周杰伦"} dict_c = dict_b = dict_a dict_a = {} dict_a # {} dict_b # {'姓名': '周杰伦'} # 通过clear方法分 dict_c.clear() dict_b # {} dict_c # {}
- 浅拷贝 copy()
a = {1:"one", 2:"two", 3:"three"} b = a.copy() c = a id(a) # 4376810192 id(b) # 4376908856 id(c) # 4376812424
- pop() 和popitem()
# pop()给定键,弹出值; popitem()是直接随机弹出一项(因为字典是没有固定顺序的) a = {1:"one", 2:"two", 3:"three"} value1 = a.pop(2) # two a # {1: 'one', 3: 'three'} value2 = a.popitem() # (3, 'three') a # {1: 'one'}
- setdefault(key[, value]), 可以添加新的key-value pair
- dict1.update(dict2) 通过dict2 去更新dict1
a = {1:"one", 2:"two", 3:"three", 7:"what"} b = {7:"seven"} c = {4:"four"} a.update(b) # {1: 'one', 2: 'two', 3: 'three', 7: 'seven'} a.update(c) # a还是a,因为a中没有4
第20节 映射-序列之集合
-
集合,不允许有重复元素,也是用花括号, 集合是没有顺序的
-
创建集合
# {} set1 = {,} set2 = {1, 2, 3, 4, 5, 5} # set 工厂函数 set3 = set() set4 = set([1,2,3,4,5]) # 不可变的集合 set5 = frozenset([1,2]) set5.add(6) # 报错,AttributeError
-
访问集合元素
# 索引是不能用的,因为集合是无序的 set2 = {1, 2, 3, 4, 5, 5} print(set2[2]) # 报错,TypeError # 可以通过for把集合中的数据一个一个读取出来 for num in set2: print(num) # 可以通过in和not in 判断一个元素是否在集合中 1 in set2 # True
-
常用函数
- http://bbs.fishc.com/thread-45276-1-1.html
-
用不同的词性命名,如属性名用名词,方法名用动词