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])

• 修改某个元素的值

  • 访问元素然后直接赋新值 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

• 用不同的词性命名，如属性名用名词，方法名用动词