python02---基础数据类型

python02---基础数据类型

一. 什么是数据类型

我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。

Python中常用的数据类型有多种，如下：

整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).

1.1 可变数据类型和不可变数据类型

1.1.1 可变数据类型

列表 list，字典 dict，集合 set；
不可hash

1.1.2 不可变数据类型

不可更改的数据类型（可hash），元祖，bool，数字，str

二. 基础数据类型---数字

2.1 整型（int）

跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
注意：在Python3里不再有long类型了，全都是int


除了int和long之外， 其实还有float浮点型, 复数型，但今天先不讲啦

2.1.1 bit_length()

数字主要是用于计算用的，使用方法并不是很多，就记住一种就可以：

#bit_length() 当十进制用二进制表示时，最少使用的位数
v = 11
data = v.bit_length()
print(data)

2.2 浮点型（float）

三. 布尔值 bool

布尔类型很简单，就两个值 ，一个True(真)，一个False(假), 主要用记逻辑判断

但其实你们并不明白对么？ let me explain, 我现在有2个值 ， a=3, b=5 , 我说a>b你说成立么? 我们当然知道不成立，但问题是计算机怎么去描述这成不成立呢？或者说a< b是成立，计算机怎么描述这是成立呢？
没错，答案就是，用布尔类型

布尔值就两种：True，False。就是反应条件的正确与否。

真   1   True。
假   0   False。

字符串
'' 空为 False，非空位True

四. 字符串 str

在Python中,加了引号的字符都被认为是字符串！

name = "Alex Li" #双引号
age = "22"       #只要加引号就是字符串
age2 = 22          #int

msg = '''My name is taibai, I am 22 years old!'''  #我擦，3个引号也可以

hometown = 'ShanDong'   #单引号也可以

那单引号、双引号、多引号有什么区别呢？

让我大声告诉你，单双引号木有任何区别，只有下面这种情况 你需要考虑单双的配合

msg = "My name is Alex , I'm 22 years old!"

多引号什么作用呢？作用就是多行字符串必须用多引号

msg = '''
今天我想写首小诗，
歌颂我的同桌，
你看他那乌黑的短发，
好像一只炸毛鸡。
'''
print(msg)

字符串拼接

数字可以进行加减乘除等运算，字符串呢？让我大声告诉你，也能？what ?是的，但只能进行"相加"和"相乘"运算。

>>> name
'Alex Li'
>>> age
'22'
>>> 
>>> name + age  #相加其实就是简单拼接
'Alex Li22'
>>> 
>>> name * 10 #相乘其实就是复制自己多少次，再拼接在一起
'Alex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex Li'

注意，字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接

>>> type(name),type(age2)
(<type 'str'>, <type 'int'>)
>>> 
>>> name
'Alex Li'
>>> age2
>>> name + age2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects #错误提示数字 和 字符 不能拼接

4.1 索引

索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

# 索引从0开始
s='ABCDEFGHIJK'

# 索引，每一次检索都是创建了一个新的字符串，原字符串不发生变化
print(s[0])  # 顺序取
print(s[-1]) # 逆序取

4.2 切片

切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。

# 切片 ABCD , 顾头不顾尾，尾+1
print(s[0:3])
print(s[0:4])  # s[首:尾]
print(s,s[:],s[0:]) # 全量的三种方法

# 取 A,C,F
print(s[0:5:2])  # s[首:尾:步长]

# 逆序取
print(s[-1::-1])  # s[首:尾:步长]
print(s[::-1])

取全量

# 正向取
print(s,s[:],s[0:]) # 全量的三种方法

# 逆序取
print(s[-1::-1])  # s[首:尾:步长]
print(s[::-1])

4.3 大小写转换

4.3.1 upper() 转大写

s = 'superVi teacher2 help*you'
# 大小写转换，对数字没有影响
# 使用场景：验证码
print(s.upper())     # 转 大写

4.3.2 lower() 转小写

s = 'superVi teacher2 help*you'
print(s.lower())     # 转 小写

4.3.3 capitalize() 仅首字母大写

s = 'superVi teacher2 help*you'
s2 = 'sup	erVi teacher	2 he	lp*you'

print(s.capitalize())  # 仅首字母大写  Supervi

4.3.4 swapcase() 大小写反转

s = 'superVi teacher2 help*you'
print(s.swapcase())  # 大小写反转  SUPERvI

4.4 排版

4.4.1 center() 居中

在特定宽度中，居中输出字符串，空余部分指定字符填充

s = 'superVi teacher2 help*you'

# 内容居中，长度，空白处填充
print(s.center(50,'@'))  # center(长度,'填充物') 默认为空格
print(s.center(5,'@'))  # 如长度不够，输出原字符，排版失败

4.4.2 expandtabs() 特定宽度

# 制表符宽度，补齐
s2 = 'sup	erVi teacher	2 he	lp*you'
print(s2.expandtabs())     # 默认将转换，	 = 8 位(
print(s2.expandtabs(3))    # 如果字符等于8位，则不作转换，不满足8位的补足

4.4.3 format() 格式化输出

#format的三种玩法 格式化输出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

4.4.4 title() 单词以大写字母开头

s = 'superVi teacher2 help*you'
print(s.title())     # 仅单词首字母大写，间隔符需特殊字符（包含数字）

4.5 条件检索

4.5.1 startswith() / endswith() 以...开头/结尾

以...开头，结尾

print(s.startswith('s'))   # 判断是否已...开头，返回bool值
print(s.startswith('u',2,4))   # 判断切片位置，是否以...开头
print(s.endswith(''))

4.5.2 find() / index 检索元素位置

检索元素位置

# 是否包含指定字符串,返回索引
print(s.find('u'))  # 通过元素，找索引下标(第一个)，找不到返回-1
print(s.find('M'))  # 找不到返回-1

# 检索元素位置，找不到报错
print(s.index('u'))  # 通过元素，找索引下标（第一关）
# print(s.index('M'))  # 找不到，报错

4.5.3 由...组成

元素是否由什么组成

#####is系列
name='taibai123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成

4.6 分割 / 拆分 / 替换

4.6.1 split() 文本分割 （字符串转换列表）

字符串分割,以什么分割，最终形成一个列表此列表不含有这个分割的元素,


默认分割字符为空格或多个空格,其它字符不可以

# 拆分，分割文本 ，split  ; str --> listPython
s = 'superVi teacher2 help*you'
s1 = ' superVi teacher2 help*you'

print(s.split(' '))  # ['superVi', 'teacher2', 'help*you']
print(s.split('*'))  # ['superVi teacher2 help', 'you']
print(s1.split(' '))  # ['', 'superVi', 'teacher2', 'help*you']

返回值需要有一个列表来接收

4.6.2 replace() 替换

把...替换为...替换次数

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

4.7 其它

4.7.1 count() 统计指定元素出现的次数

#数字符串中的元素出现的个数。
ret3 = a1.count("a",0,4) # 可切片
print(ret3)

4.7.2 strip() 按序消除字符串

#strip
name='*barry**'
print(name.strip('*')) 
print(name.lstrip('*'))
print(name.rstrip('*'))

4.8 随手写了个bug

str1 = input('我要判断，你输入数次的个数，多个数字相连判做一个数字! >>>') # w3t4h5u7i8g445fdgt3

for i in str1:
    if i.isalpha():
        str1=str1.replace(i,' ')

print(str1.split())

五. 列表 list

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = ['alex',123,True,(1,2,3,'wusir'),[1,2,3,'小明',],{'name':'alex'}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

5.1 列表的索引和切片

# 取单个元素的时候，这个元素是什么类型，取出来就是什么类型
# 切片操作时，取到的为列表类型

li = ['alex',123,True,(1,2,3,'wusir'),[1,2,3,'小明',],{'name':'alex'}]

print('列表：',li,'
')
print('第一个元素',li[0])
print('前3个元素',li[0:4])

5.2 列表操作---增

5.2.1 append() 尾部追加

没有返回值,None

li = ['1',2,[3,4]]
print(li)   # ['1', 2, [3, 4]]

li.append('end')
print(li)   # ['1', 2, [3, 4], 'end']

示例：追加花名册，

while 1:
    username = input("输入名字,ok 退出：>>> ")
    if username.lower().replace(' ','')!='ok':
        li.append(username)
        continue
    break
print(li)


while 1:
    username = input("输入名字,ok 退出：>>> ")
    if username.lower().replace(' ','')=='ok':break
    li.append(username)
print(li)

5.2.2 insert 指定位置插入

li = [1,2,3,4]

li.insert(1,'long')
print(li)

5.2.3 extend 可迭代对象

将可迭代对象的元素，依次追加至最后

• 字符串：转化为单字符进行追加
• 列表：将各元素依次追加

# 原字符串
bjx = ["zhao"]
bjx.extend('qian')
print(bjx)

# 追加列表
bjx.extend(['qian','sun'])
print(bjx)

5.3 列表操作---删

• 按元素   ---  remove()
• 按索引   ---  pop()
• 清空   ---   clear() / del

5.3.1 pop() 根据索引删除

返回索引对应的元素，并在原列表中删除，找到返回元素，找不到报错

li = [1, 2, 3, 4]
li.pop(1)
print(li)  # [1, 3, 4]

# 为空时，删除最后一位

5.3.2 remove 按照元素删除

按照元素去删，只删除一个，顺序从左向右,找到返回None，找不到返回错误

# remove
li = [1, 2, 3,4,3]
li.remove(3)
print(li)   # [1, 2, 4]

# li.remove()  # 报错

5.3.3 clear() 清空列表

清除元素，保留列表指针

li = [1, 2, 3,4,3]
li.clear()
print(li)  # []

5.3.4 del 删除列表

删除列表，释放内存空间（删除指针）

li = [1, 2, 3,4,3]
del li
print(li)  # NameError: name 'li' is not defined

切片去删

li = [1, 2, 3,4,3]

del li[2:] # [1, 2]
print(li)

5.4 列表操作---改

5.4.1 根据索引去改

li = [1, 2, 3, 4, 5]
li[0]='yi'
print(li)

5.4.2 根据切片去改

用切片的方式修改列表，如果值是可迭代对象，则在切片位置依次插入可迭代对象的每一个元素

li = [1, 2, 3, 4, 5]
li[0:2]='一二'   # 等值替换
print(li)   # ['一', '二', 3, 4, 5]

li[0:2]='一'  # 切片个数被一个元素所替代
print(li)    # ['一', 3, 4, 5]

li[0:2]='一二san' # 所替换元素的个数大于切片的个数
print(li)    # ['一', '二', 's', 'a', 'n', 3, 4, 5]

切片修改不可迭代对象

li = [1, 2, 3, 4, 5]
li[0:2]=2,2
print(li)    # ['一', '二', 's', 'a', 'n', 3, 4, 5]

li = [1, 2, 3, 4, 5]
li[0:2]=2    # 当不是可迭代对象时，被替换的数量要不少于切片元素数量
print(li)    # ['一', '二', 's', 'a', 'n', 3, 4, 5]

情景展示

Traceback (most recent call last):
['yi', 2, 3, 4, 5]
  File "D:/workSpace/python/day04/1.list.py", line 94, in <module>
    li[0:2]=2
TypeError: can only assign an iterable

5.5 列表的操作---查

5.5.1 查看整个列表

用 for 循环

li = [1, 2, 3, 4, 5]

for i in li:
    print(i)

5.5.2 根据切片查看

li = [1, 2, 3, 4, 5]
print(li[0:3])

5.6 公共方法

5.6.1 len 长度

li = [1, 2, 3, 4, 5,3,3,3]
print(len(li))

5.6.2 count  次数统计

li = [1, 2, 3, 4, 5,3,3,3]
print(li.count(3))

5.6.3 index 查找索引

找不到报错

li = [1, 2, 3, 4, 5,3,3,3]
print(li.index(3))

print(li.index(33))    # ValueError: 33 is not in list

5.7 排序

5.7.1 sort(reverse=True) 正向排序

li = [1, 2, 3, 4, 5,3,3,3]
li.sort()
print(li)

5.7.2 sort 逆向排序

li = [1, 2, 3, 4, 5,3,3,3]

li.sort(reverse=True)
print(li)

5.7.3 reverse 顺序反转

li = [1, 2, 3, 4, 5, 3, 3, 3]

li.reverse()
print(li)

5.8. 列表的嵌套

列表里面嵌套列表，就是列表的嵌套了

5.8.1 修改元素

列表是由一个个多元化的元素组成的，在修改的时候，我们可以通过取这个列表的元素，根据元素的类型，来进行相应的操作

li = ['xiaobai','苍劲空','乔延难',['name','age','sex']]
print(li[1][1])

li[1]=li[1].replace('劲','井')
print(li)

5.9 其它

5.9.1 join(iterable) 可迭代对象转换成字符串

根据提供的字符串，来连接可迭代对象，返回字符串

s=xiaobai
'_'.join(s) # x_i_a_o_b_a_i

示例：列表和字符串互转

li = ["zhao",'qian','sun','li']
li2 = ["zhao",'qian','sun','li',['aa','bb']] # 这个是不可以用 join 进行拼接的
print(li)

s = '_'.join(li)
print(s)

l2 =s.split('_')
print(l2)

5.9.2 range(start,end,步长)

可以看作一个列表

# start <= i < end
for i in range(1,20):
    print(i)

for i in range(20): # 从 0 开始写，可以不写0
    print(i)

for i in range(0,20,2): # 步长，开头不能省略
    print(i)

for i in range(10,0,-2): # 逆序取步长
    print(i)

for i in range(0,20,-1): # 错误示例，什么也不输出
    print(i)

5.9.3 多级列表元素的遍历

li = ["zhao",'qian','sun','li',['aa','bb'],1,2,[2,3]]

for i in li:
    if type(i)==list:
        for j in i:
            print(j)
        continue
    print(i)

七. 元组 tuple

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

• 可循环，可查询，可切片；
• 元祖的元素类型是不能发生变化的，元祖元素的子元素是可以修改的
• 元组里面不加逗号，切只有一个元素，该是什么类型，就是什么类型

7.1 修改元素的子元素

tu = (1,2,3,'xiaobai',[2,3,4,'yisheng','happy'])

# 遍历元祖元素
for i in tu:
    print(i)

# 取构成元祖元素的子元素
print(tu[4][3])

# 修改元祖元素的子元素
tu[4][3]=tu[4][3].upper()
print(tu[4][3])

7.2 元组的一级元素是不可改变的

八. 字典 dict

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组、bool值。
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合**。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典的优点：寻找速度快，二分查找法去查询，
如何初始化一个字典？

特点：

• 储存大量的关系型数据
• 无序的（3.5 ／ 3.6）之前，
• 查询速度非常快

8.1 如何定义字典？

字典的构成需要有三个元素，字典名字，键值对（key，value），键值对可为空

dicName={
    'key':['字符串','可以当 key'],
    2:'数字类型，可以当 key',
    (1,2,3):['元祖','可以当 key'],
    True:'bool 值，也可一当key'
}
dicTest2={}
print(dicName,dicTest2)

结果

# {'key': ['字符串', '可以当 key'], 2: '数字类型，可以当 key', (1, 2, 3): ['元祖', '可以当 key'], True: 'bool 值，也可一当key'} {}

8.2 字典的增加

8.2.1 dic[haha]='xiao;

有的覆盖，没有的添加
根据key值，直接修改，没有的增加，有的修改 value

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}

dicAdd['sex']='M'     # 没有增加
dicAdd['name']='Li'   # 有的更改

print(dicAdd)

8.2.2 setdefault(key,value)

没有的添加，有的不做修改

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}

dicAdd.setdefault('妻子')        # '妻子': None 不设置value，None填充
dicAdd.setdefault('兴趣','HGN')  # 添加，没有直接加上

dicAdd.setdefault('age',100) # 直接修改生死簿，走好了您
print(dicAdd)    # 没有拿到判官笔，修改失败

8.3 字典的删除

8.3.1 pop(key,value)，有返回值

找到key，删除；找不到，返回错误，如果定义返回值，则返回定义的值

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}


print(dicAdd.pop('name'))             # 找到要删除的key，删除
print(dicAdd.pop('name1'))            # 找不到要删除的key，报错

print(dicAdd.pop('name','meiyou'))    # 找到要删除的key，返回key
print(dicAdd.pop('name1','meiyou'))   # 找不到要删除的key，返回自定的value

print(dicAdd)

8.3.2 pop.item()

自后向前删，有返回值，无参； 老版本是随机删除,返回被删除的键值组成的元组

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}
print(dicAdd.popitem())   # 被删除内容，('name', 'xiaobaiyisheng')
print(dicAdd.popitem())   # 被删除内容，('age', 18)
print(dicAdd.popitem())   # popitem(): dictionary is empty

# 不要尝试添加参数，这是不理智的
print(dicAdd.popitem('age'))   # TypeError: popitem() takes no arguments (1 given)

8.3.3 clear()

8.3.4 del

删除，无返回值

dicAdd= {'age': 18, 'name': 'xiaobaiyisheng'}
del dicAdd
del dicAdd['age']

8.4 改

8.4.1 覆盖

8.4.2 update()

值不同的进行更新，key没有的进行添加

dic = {"name":"xiaobai","age":18,"sex":"man"}
dic2 = {"name":"xiaobaiyisheng","weight":75}

dic.update(dic2)  # dic 来保存 dic2的更新
print(dic,dic2)

8.5 查

8.5.1 打印字典

dic = {"name":"xiaobai","age":18,"sex":"man"}

print(dic.keys(),type(dic.keys()))       # key 组成的 列表
print(dic.values(),type(dic.values()))   # value 组成的列表
print(dic.items(),type(dic.items()))     # key和值组成的，元祖形式组成的列表

打印键值

dic = {"name":"xiaobai","age":18,"sex":"man"}
for i in dic.items():
    print(i)

for k,v in dic.items():
    print(k,v)

8.5.2 get() 根据key找

根据key取值，默认取不到返回错误，可以指定返回值

dic = {"name":"xiaobai","age":18,"sex":"man"}

dic.get('name1')       # error
print(dic.get('name1',1))
print(dic.get('name',1))
print(dic)

8.6 字典的嵌套

示例列表

dic = {
    'name': ['zhangsan', 'lisi', 'wangwu'],
    '11': {
        'time': '1213',
        'learn_money': 19800,
        'addr': 'CBD'
    },
    'age': 21
}

8.6.1 添加

#  name 列添加 zhaoliu
print(dic['name'].append('zhaoliu'))
print(dic)

#  在 11 的字典 里，添加 一个键值对
dic['11'].setdefault('女生',6)
dic['11']['男生']=7
print(dic)

8.6.2 修改

# 修改 age 30
dic['age'] = 210

# lisi 大写
dic['name'][1]=dic['name'][1].upper()
print(dic)

九. 集合

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。
以下是集合最重要的两点：

• 去重，把一个列表变成集合，就自动去重了。
• 关系测试，测试两组数据之前的交集、差集、并集等关系。

9.1 集合的声明

set1 = set({1,2,3,4,'1',(1,2,3,),True,'AAA','AAA',False,3})
print(set1)   
# {'1', 1, 2, 3, 4, False, (1, 2, 3)}
# 并没有打印 True
# 集合是无序的
# 集合是不重复的 

尝试在集合中包含可变类型数据

# set2={1,2,3,[2,3],{'name':123}}
# print(set2)   # TypeError: unhashable type: 'list'

set3={1,2,3,{'name':123}}
print(set3)    # TypeError: unhashable type: 'dict'

9.2 增

9.2.1 add()

set1 ={'ZHAO','QIAN','SUN','LI'}
set1.add('zhou')
print(set1)

9.2.2 update 迭代添加

传递一个可迭代对象的时候，会依次添加的

set1 ={'ZHAO','QIAN','SUN','LI'}

set1.update('123')
print(set1)

# {'2', 'zhou', 'SUN', '3', 'LI', 'QIAN', 'ZHAO', '1'}

set1.update([1,2,'33'])
print(set1)

# {1, 2, 'SUN', 'QIAN', '33', 'LI', 'ZHAO'}

9.3 删

9.3.1 pop() 随机删除

set1 ={'ZHAO','QIAN','SUN','LI'}
set1.pop()
print(set1)   # 每次执行，删除的结果都不一样

9.3.2 clear() 清空

简单的讲，就是值没有了

set1 ={'ZHAO','QIAN','SUN','LI'}
# set1.pop()
# print(set1.pop())
set1.clear()

9.3.3 del set 删除

del set1 
# 删了就没有了

9.3.4 查 循环便利

set1 = set({1,2,3,4,'1',(1,2,3,),True,'AAA','AAA',False,3})
for i in set1:
    print(i)

9.4 交集  （&  或者 intersection）

A 有，B也有

SET1 = {1,2,3,4,5}
SET2 = {4,5,6,7,8}

print(SET1 & SET2)   
print(SET1.intersection(SET2))

# {4, 5}

9.5 并集 （| 或者 union)

A 和 B 共有

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 | set2)
print(set1.union(set2))

# {1, 2, 3, 4, 5, 6, 7, 8}

9.6 差集 (- 或者 difference)

差集 A 有 B 没有

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

# 差集 A 有 B 没有
print(set1-set2)
print(set1.difference(set2))

# {1, 2, 3}

9.7 反交集 （^ 或者 symmetric_difference）

A 和 B 相互独立的元素的集合

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

#（^ 或者 symmetric_difference）
# A 和 B 相互独立的元素的集合 
print(set1 ^ set2)
print(set1.symmetric_difference(set2))

# {1, 2, 3, 6, 7, 8}

9.8 子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

# 子集 <
print(set1 < set2)
print(set1.issubset(set2))

# 超集 >
print(set2 > set1)
print(set2.issuperset(set1))

9.9 小例子

9.9.1 列表去重

li = [1,2,33,33,2,1,4,5,6,6]

print(list(set(li)))

9.10 forzenset() 不可变集合

不可变集合

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

十. 基础数据类型总结

10.1 按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

10.2 按可变不可变区分

可变	列表，字符串
不可变	数字，字符串，元组，布尔值

10.3 按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

十一. 其它

11.1 for循环

用户按照顺序循环可迭代对象的内容

msg='人之初，行本事，性相近，习相远'

for i in msg:
    print(i)
    
msg='人之初，行本事，性相近，习相远'

li = msg.split(',')

for i in li:
    print(i)

dic={
    'xing':['zhao','qian','sun','li'],
    'name':[1,2,3,4]
}

for k,v in dic.items():
    print(k,v)

11.2 enumerate:枚举

对于一个可迭代的（iterable）/ 可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值

msg=['人之初','行本事','性相近','习相远']

for i in enumerate (msg):
    print(i)

for index,name in enumerate(msg,1):
    print(index,name)

for index,name in enumerate(msg,100):
    print(index,name)

11.3 range

指定反问，生成指定数字

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)