天池龙珠计划-Python训练营-学习笔记-Task02

Task02

主要内容用于存储任意数量和类型Python对象的列表、定义之后通常元素不可改变的元组、字符串、字典、集合、序列

• 列表

• 元组

• 字符串

• 字典

• 集合

• 序列

Python 中的数据类型

简单数据类型
整型<class ‘int’>
浮点型<class ‘float’>
布尔型<class ‘bool’>

容器数据类型
列表<class ‘list’>
字典<class ‘dict’>
元组<class ‘tuple’>
集合<class ‘set’>
字符串<class ‘str’>

列表

1. 利用range()创建列表

x = list(range(2, 15, 2))
print(x, type(x))
# [2, 4, 6, 8, 10, 12, 14] <class 'list'>
# range(start, stop, step)

2. 利用推导式创建列表

x = [i for i in range(15, 2, -2)]
print(x, type(x))
[15, 13, 11, 9, 7, 5, 3] <class 'list'>

x = [i for i in range(15) if (i % 2) != 0 and (i % 3) ==0]
print(x, type(x))
[3, 9] <class 'list'>

3. 批量复制列表

a = [0]
x = [a * 3] * 4
print(x , type(x))

x[0][0] = 1
print(x, type(x))
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>
[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'> 
# 通过 * 批量复制列表，原理是通过创建4个对a的引用，a一变，x中的4个a也会随之改变

4. 向列表中添加元素

x = ['CHN', 'USA', 'GRB', 'JPN', ]
x.append(['CAN','FRA'])
print(x, type(x))
# ['CHN', 'USA', 'GRB', 'JPN', ['CAN', 'FRA']] <class 'list'>
# append(obj) 作为一个整体追加到列表后面 

x.extend(['CAL','CAF'])
print(x, type(x))
# ['CHN', 'USA', 'GRB', 'JPN', ['CAN', 'FRA'], 'CAL', 'CAF'] <class 'list'>
# extend(seq) 扩展原来的列表

x.insert(2, 'FIN')
print(x, type(x))
# ['CHN', 'USA', 'FIN', 'GRB', 'JPN', ['CAN', 'FRA'], 'CAL', 'CAF'] <class 'list'>
# insert(index, obj)

5. 删除列表中的元素

x.remove('CAL')
print(x)
# ['CHN', 'USA', 'GRB', 'JPN', ['CAN', 'FRA'], 'CAF']

x.pop(3)
print(x)
#['CHN', 'USA', 'FIN', 'JPN', ['CAN', 'FRA'], 'CAF']

del x[1:3]
print(x)
# ['CHN', 'JPN', ['CAN', 'FRA'], 'CAF']

5. 获取列表中元素

print(x[:3:2])
# ['CHN', ['CAN', 'FRA']]
# [start:stop:step]

list1 = [1, 3, 2]
list2 = list1
list3 = list1[:]
print(list2) # [1, 3, 2]
print(list3) # [1, 3, 2]
list1.sort()
print(list2) # [1, 2, 3]
print(list3) # [1, 3, 2]
# 列表的浅拷贝和深拷贝
# 浅拷贝由于是同一个引用所以被赋值的list2，会随着list1的改变而改变
# 深拷贝则不受影响

6. 列表中的常用操作符

• 等号操作符 ==

• 连接操作符 +

• 重复操作符 *

• 成员关系操作符 in、not in

• 列表中的其他方法

  • list.count(obj) : 统计元素在列表中出现的次数

  • list.index(x[, start[, end]])

  • list.reverse() 反向列表中的元素

  • list.sort(key=None, reverse=False)

    • key-- 用来比较的元素，取自可迭代对象中，指定可迭代对象中的一个元素来进行排序
    • revere – 排序规则，reverse = True 降序

  获取列表的第二个元素

  def takeSecond(elem):
      return elem[1]
  
  x = [(2, 2), (3, 4), (4, 1), (1, 3)]
  x.sort(key=takeSecond)
  print(x)
  # [(4, 1), (2, 2), (1, 3), (3, 4)]
  
  x.sort(key=lambda a: a[0])
  print(x)
  # [(1, 3), (2, 2), (3, 4), (4, 1)]
  
  # takeSecond()相当于根据第二列值的大小进行升序排序
  # lambda a: a[0] 相当于根据第一列值的大小进行升序排序
  
  ```
  

元组

定义

(元素1， 元素2，… ， 元素n)

1. 创建和访问元组

• tuple与列表类似，但创建之后类似字符串，不能对其修改

• 同样有indexing（索引）、slicing（切片）操作

• 特殊情况

  • 只有一个元素应为（元素1,）无**‘,’**，则括号会被识别为运算符处理

  • 二维元组：x = (元素1, 元素2, 元素3), (元素1, 元素2, 元素3)

2. 更新和删除一个元组

• 只当元组中的元素可改(mutable),才可改变元素

3. 元组相关的操作符

• 与列表(list)中基本方法相似类似

4. 内置方法

• count()、index()可用

  t = (3.14, 'pi', 'pi', 'circle')
  print(t.count('pi')) # 2
  print(t.index('circle')) # 3
  

5. 解压元组

• 解压一维元组

  t = (3.14, 'pi', ('radius', 'circle'))
  (a, b, (c, d)) = t
  print(a, b, c, d) # 3.14 pi radius circle
  

• 通配符 * ,把一个或多个元素丢给rest(_)

  t = 6, 5, 4, 3, 2, 1
  a, b, *rest, c = t
  print(a, b, c) # 6 5 1
  print(rest, type(rest)) # [4, 3, 2] <class 'list'>
  
  a, b, *_ = t
  print(a, b) # 6 5
  

字符串

定义

• 引号之间的字符合集

• 使用成对的单、双引号

常用转义字符

转义字符	描述
\\	反斜杠符号
\'	单引号
\"	双引号
\n	换行
\t	横向制表符(TAB)
\r	回车

print('C:\\now') # C:\now
print('C:\\Program Files') # C:\Program Files
print(r'C:\Program Files') # C:\Program FIles

para_str = """
多行字符串
可以使用(\t)、(\n)等转义字符
"""
# 多行字符串
# 可以使用(	)、(
# )等转义字符

2. 字符串的切片和拼接

• 有正负、从0开始的索引
• 有start:end
• 类似于元组的不可修改

str = 'Hello Python String'
print(str[:6:]) # Hello

3. 字符串的常用内置方法

• 大小写转化

  • capitalize()把第一个字符转化为大写
  • lower() 大写字符转化为小写
  • upper() 小写字符传化为大写
  • swapcase() 大写转化为小写，小写转化为大写

• 计算次数

  # count(str, beg, end=len(string))
  str = 'Hello Hello hello'
  print(str.count('Hello')) # 2
  print(str.count('Hello', 0, 6)) # 1
  

• 检查指定子字符串是否在字符串中

  函数	功能	返回值
  endwith(suffix, beg=0, end=len(string))	在[beg, end]中检查是否已suffix结尾	bool
  startwith(substr, beg=0, end=len(string))	在[beg, end]中检查是否已substr开头	bool
  find(str, beg=0, end=len(string))	正序查找	-1/index
  rfind(str, beg=0, end=len(string))	倒序查找	-1/index
  isnumeric()	字符串中只包含数字字符	bool

• 调整格式

  函数	功能	返回值
  ljust(width[,fillchar])	将字符串左对齐，用fillchar填充至长度为width	字符串
  rjust(width[,fillchar])	将字符串右对齐，用fillchar填充至长度为width	字符串
  lstrip([chars])	截掉字符串左边的空格或指定字符	字符串
  rstrip()[chars]	删除字符串末尾的空格或指定字符	字符串
  strip([chars])	lstrip()和rstrip()的功能	字符串

• 分割字符串

  函数	功能	返回值
  partition(sub)	返回以sub分割的三元组	(pre_sub, sub, fol_sub)
  rpartition(sub)	从右边查找	(pre_sub, sub, fol_sub)
  split(str=" ", num)	以分隔符(默认空格)切片字符串	切片后的子字符串<class ‘list’>

  str = 'Hello new  World'
  print(str.strip().partition('e')) # ('H', 'e', 'llo new  World')
  print(str.strip().rpartition('e'))# ('Hello n', 'e', 'w  World')
  print(str.strip().split('e')) # ['H', 'llo n', 'w  World']
  print(str.strip().split('e', 1)) # ['H', 'llo new  World'] 
  

• 替换字符串

  replace(old, new [, max])

• 其他

  • splitlines([keepends])

  • maketrans(intab, outtab)

  • translate(table, deletechar)

4. 字符串格式化

• format格式化参数

  str = "{0} new {b}".format('Hello', b='World') # 位置参数{0} 关键字参数{b}
  print(str) # Hello new World
  

• python字符串格式化符号

  符 号	描述
  %c	格式化字符及其ASCII码
  %s	格式化字符串，用str()方法处理对象
  %r	格式化字符串，用rper()方法处理对象
  %d	格式化整数
  %o	格式化无符号八进制数
  %x	格式化无符号十六进制数
  %X	格式化无符号十六进制数（大写）
  %f	格式化浮点数字，可指定小数点后的精度
  %e	用科学计数法格式化浮点数
  %E	作用同%e，用科学计数法格式化浮点数
  %g	根据值的大小决定使用%f或%e
  %G	作用同%g，根据值的大小决定使用%f或%E

  print("现在是 %d 年，为%s年" % (2021, '牛')) # 现在是 2021 年，为牛年
  

• 格式化操作符辅助指令

  符号	功能
  m.n	m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）
  -	用作左对齐
  +	在正数前面显示加号( + )
  #	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
  0	显示的数字前面填充’0’而不是默认的空格

字典

1. 可变类型和不可变类型

	索引类型	索引	索引可变与否
字典	映射	关键字（字符串或数值）	任意不可变
字符串、元组、列表	序列	连续的整数	可变

	类型
数值、字符、元组	不可变（能被哈希）
列表、集合、字典	可变（不能被哈希）

判断方法：

• hash(X),X可被哈希即不可变，反之则可变

• 用id(X),查看改变前后地址是否相同，不同即不可变、反之可变

2. 字典的定义

无序的键:值(key:value)对集合,键必须是互不相同的

字典 定义语法为 {元素1, 元素2, …, 元素n}

• 其中每一个元素是一个「键值对」-- 键:值 (key:value)
• 关键点是「大括号 {}」,「逗号 ,」和「冒号 :」
• 大括号 – 把所有元素绑在一起
• 逗号 – 将每个键值对分开
• 冒号 – 将键和值分开

3. 创建和访问字典

dic1 = {1: 'one', 2: 'two', 3: 'three'}
print(dic1)  # {1: 'one', 2: 'two', 3: 'three'}
print(dic1[1])  # one

• dict()创建一个空的字典

  dic = dict()
  dic['a'] = 1
  dic['b'] = 2
  dic['c'] = 3
  
  print(dic)
  # {'a': 1, 'b': 2, 'c': 3}
  

• dict(mapping)

  dic = dict((('one',1), ('two',2), ('three',3)))
  print(dic) # {'one': 1, 'two': 2, 'three': 3}
  

• dict(**kwargs)

  dic = dict(one=1, two=2) 
  print(dic) # {'one': 1, 'two': 2}
  

4. 字典的内置方法

• dict.fromkeys(seq[, value])

  seq = ('year', 'month', 'day')
  dic = dict.fromkeys(seq, [2020, 1, 1])
  print(dic) # {'year': [2020, 1, 1], 'month': [2020, 1, 1], 'day': [2020, 1, 1]}
  

• dict.keys()、dict.values()、dict.items()

  print(list(dic.values())) # [[2020, 1, 1], [2020, 1, 1], [2020, 1, 1]]
  print(list(dic.items())) # [('year', [2020, 1, 1]), ('month', [2020, 1, 1]), ('day', [2020, 1, 1])]
  

• dict.get(key, default=None)、dict.setdefault(key, default=None)

• key in dict (not in)

  if 'year' not in dic:
      print("key 'year' does not in dic")
  else:
      print("ket 'year' did  in dic")
  # ket 'year' did  in dic
  

• dict.pop(key, [, default])、del dict[key]

  dic1 = {1: "a", 2: [1, 2]}
  print(dic1.pop(1), dic1)  # a {2: [1, 2]}
  del dic1[2]
  print(dic1)  # {}
  

• dict.popitem()

  dic1 = {1: "a", 2: [1, 2]}
  print(dic1.popitem())  # {2: [1, 2]}
  print(dic1)  # (1, 'a')
  

• dict.copy()与直接赋值区别在于copy()会开创一个新的空间用来放新的对象

• dict.update(dic2)会把dic2中的key:value更新到dict中

集合

1. 集合的创建

• set()创建

  basket = set()
  basket.add('apple')
  basket.add('banana')
  print(basket)  # {'banana', 'apple'}
  

• {元素1， 元素2，....}

  basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
  print(basket)  # {'banana', 'apple', 'pear', 'orange'}
  

• set(value)把列表或元组转换成集合（会自动除去列表中重复的元素）

  a = set('abracadabra')
  print(a)  
  # {'r', 'b', 'd', 'c', 'a'}
  
  b = set(("Google", "Tianmao", "Taobao", "Taobao"))
  print(b)  
  # {'Taobao', 'Tianmao', 'Google'}
  

• 集合中没有索引、切片操作、键

2. 访问集合中的值

• len()得到集合大小
• 用for逐个读取
• in not in判断是否在集合中

3. 集合的内置方法

• set.add(elemnt)添加元素

• set.update(set)相当于两个集合的并集

• set.remove(item) set.diacard(value)移除指定元素

• set.pop()随机移除一个元素

• 运算	函数	运算符	运算会改变原来集合
  交集	set.intersection(set1, set2)	set1&set2	set.intersection_update(set1, set2)
  并集	set.union(set1, set2)	set1 | set2
  差集	set.difference(set)	set1 - set	set.difference_update(set)
  异或	set.symmetric_difference(set)	set1 ^ set2	set.symmetric_difference_update(set)
  是否是其他集合子集	set.issubset(set)	set1 <= set2
  是否包含其他集合	set.issuperset(set)	set1 >= set2
  判断两个集合是否相交	set.isdisjoint(set)

4. 集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>

5. 不可变集合

frozenset([iterable])返回一个冻结的集合

序列

在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

• 类型转换 list(sub)、tuple(sub) str(obj)

• 返回对象长度 len(s)

• min(sub) max(sub) sum(iterable[, start=0])

  print(sum([1, 3, 5, 7, 9]))  # 25
  print(sum([1, 3, 5, 7, 9], 10))  # 35
  

• 排序 sorted(iterable, key=None, reverse=False)

• 顺序反转reversed(seq)

• enumerate(sequence, [start=0])

  seasons = ['Spring', 'Summer', 'Fall', 'Winter']
  a = list(enumerate(seasons))
  print(a)  
  # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
  
  for i, element in a:
      print('{0},{1}'.format(i, element))
  # 0,Spring
  # 1,Summer
  # 2,Fall
  # 3,Winter
  

• zip(iter1 [,iter2 [...]])

  • 用于节约内存，用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象

  • 可以用list()转化

  • 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表

    a = [1, 2, 3]
    b = [4, 5, 6]
    c = [4, 5, 6, 7, 8]
    
    zipped = zip(a, b)
    print(zipped)  # <zip object at 0x000000C5D89EDD88>
    print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
    zipped = zip(a, c)
    print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
    
    a1, a2 = zip(*zip(a, b))
    print(list(a1))  # [1, 2, 3]
    print(list(a2))  # [4, 5, 6]
    

参考连接：
1.python深拷贝和浅拷贝的区别