Python开发【第三篇】基本数据类型

整型 int

__author__ = 'Tang'

# 将字符串转换为数字
a = ""
b = int(a)
print(b) #

# 前面是0的数转换，默认base按照十进制
a = ""
b = int(a)
print(b) #

# 通过base,按照指定进制转换为十进制
a = ""
b = int(a,base=16)
c = int(a,base=8)
print(b) #
print(c) #

# bit_length() 表示这个数字的二进制至少用几位来表示
a = 15 #
b = 16 #
c = a.bit_length()
d = b.bit_length()
print(c) #
print(d)#

# a = "0b11"
# b = int(a)
# print(b) # 报错

# a = "123a"
# b = int(a)
# print(b) # 报错

字符串 str

 __author__ = "Tang"

 """不要指望一下全背下来"""
 """必会的：join split find strip upper lower replace"""

 # capitalize() 首字母大写
 a = 'tang'
 b = a.capitalize()
 print(b) # Tang

 # casefold() 大写变小写
 a = 'TANg'
 b = a.casefold()
 print(b) # tang

 # lower() 大写变小写
 a = 'TANg'
 b = a.lower()
 print(b) # tang

 """
 casefold() & lower() 的比较
 1.都能大写变小写
 2.casefold 比较全面，像一些特殊语言的变换都可以
 3.lower 只能处理英文转换
 """

 # center() 字符串放中间
 # center(self, width, fillchar=None) width=总长度 fillchar=填充符号(一个字符)
 a = 'tang'
 b = a.center(20)
 c = a.center(20,'*')
 d = a.center(20,'唐')
 print(b) #         tang
 print(c) # ********tang********
 print(d) # 唐唐唐唐唐唐唐唐tang唐唐唐唐唐唐唐唐

 # count() 统计次数
 # count(self, sub, start=None, end=None) sub=要统计的字符 start=开始位置 end=结尾位置 以0开始计数 [start,end)
 a = 'tanglaoertanglaoer'
 b = a.count('a')
 c = a.count('ao')
 d = a.count('a',5,-1)
 e = a.count('r',0,-1)
 f = a.count('r',0)
 print(b) #
 print(c) #
 print(d) #
 print(e) #
 print(f) #

 # endswith() 判断以什么结尾
 # endswith(self, suffix, start=None, end=None) suffix=要判断的字符 start=开始位置 end=结尾位置 以0开始计数 [start,end)
 a = 'tanglaoer'
 b = a.endswith('er')
 print(b) # True

 # expandtabs() 每次取tabsize个，里面有\t的补后面的空格
 # expandtabs(self, tabsize=8)
 a = 'tanglaoer\t' # 这里补三个空格 第一次取tangla   第二次取oer\t
 b = a.expandtabs(6)
 print(b) # tanglaoer | | |
 print(len(b)) #

 # find() 寻找 返回所在位置,未找到返回-1
 # find(self, sub, start=None, end=None) sub=要查找的字符 start=开始位置 end=结尾位置 以0开始计数 [start,end)
 a = 'tanglaoer'
 b = a.find('a')
 c = a.find('a',3)
 e = a.find('p',3)
 print(b)#
 print(c)#
 print(e)# -1

 # format 格式化，占位符替换为指定的值
 # format(self, *args, **kwargs)
 a = 'i am {name}'
 print(a) # i am {name}
 b = a.format(name='tang')
 print(b) # i am tang

 a = 'i am {0},age {1}'
 print(a) # i am {0},age {1}
 b = a.format('tang','')
 print(b) # i am tang,age 22

 # format_map() 格式化
 # format_map(self, mapping) mapping=字典{}
 a = 'i am {name}'
 b = a.format_map({'name':'tang'}) # 传字典
 print(b) # i am tang

 # index() 寻找,找不到就报错
 # index(self, sub, start=None, end=None) sub=要查找的字符 start=开始位置 end=结尾位置 以0开始计数 [start,end)
 # a = 'tanglaoer'
 # b = a.index('a')
 # c = a.index('p')
 # print(b) # 1
 # print(c) # 报错

 """
 find() & index() 的比较
 1. 用find() 找不到不会报错
 """

 # isalnum() 字符串中是否只包含 字母（包括汉字）和数字
 a = 'tang8080唐'
 b = 'tang8080_'
 c = a.isalnum()
 d = b.isalnum()
 print(c) # True
 print(d) # False

 # isalpha() 字符串是否只包含字母 汉字
 a = "tanglaoer"
 b = '唐'
 c = a.isalpha()
 d = b.isalpha()
 print(c) # True
 print(d) # True

 # isdigest() isdecimal() 判断是否是数字
 a = ""
 b = "②"
 t = '二'
 c = a.isdecimal() # 只可以识别 这种"123" 用来判断计算就用这种
 d = a.isdigit()
 e = b.isdecimal()
 f = b.isdigit()
 g = t.isnumeric() # 可以识别中文数字
 print(c,d,e,f,g) # True True False True True
 """
 isdigit() & isdecimal() 比较
 1. 用isdigit() 范围更广
 """

 # swapcase() 大小写转换
 a = 'TangLaoEr'
 b = a.swapcase()
 print(b) # tANGlAOeR

 # isidentifier() 判断是否是标识符
 # 数字 字母 下划线 and 字母 下划线 开头

 # isprintable() 判断是否存在不可显示字符 \n \t ，注意：空格是可显示的
 a = "tang\tlao"
 b = a.isprintable()
 print(b) # False

 # isspace() 判断是否全部是空格，\t \n 都满足
 a = "tanglaoer"
 b = " "
 t = "\t"
 p = "\n"
 c = a.isspace()
 d = b.isspace()
 g = t.isspace()
 pp = p.isspace()
 print(c,d,g,pp) # False True True True

 # istitle() 判断是否是标题 每个单词首字母大写
 a = 'tang lao er'
 b = a.istitle()
 c = a.title()
 print(b)# False
 print(c)# Tang Lao Er

 # 这个很重要
 # join() 拼接字符串 每一个元素按照指定分隔符进行拼接
 a = "tanglaoer"
 c = '飞流直下三千尺'
 print(a)
 b = " ".join(a)
 d = "_".join(c)
 print(b) # t a n g l a o e r
 print(d) # 飞_流_直_下_三_千_尺

 # ljust() rjust() 指定宽度，字符串放一边 剩下的填充
 # ljust(self, width, fillchar=None)
 # rjust(self, width, fillchar=None)
 a = 'tang'
 b = a.ljust(20,'*')
 c = a.rjust(20,'*')
 print(b) # tang****************
 print(c) # ****************tang

 # zfill() 以0来填充
 a = "tang"
 b = a.zfill(20)
 print(b) # 0000000000000000tang

 # islower() 判断是否是小写
 a = 'Tang'
 b = a.islower()
 print(b) # False

 # isupper() 判断是否是大写
 a = 'Tang'
 b = a.isupper()
 print(b) # False

 # upper() 转换为大写
 a = 'Tang'
 b = a.upper()
 print(b) # TANG

 # 移除指定字符串
 #strip() 默认去除空格 \n \t ,可以指定匹配的子序列
 # strip(self, chars=None)
 a = " tang "
 b = a.lstrip()
 c = a.rstrip()
 d = a.strip()
 print(b)#tang
 print(c)# tang
 print(d)#tang

 # 注意：是子序列里面的都可以匹配掉
 a = 'axtangxa'
 b = a.lstrip('ax')
 c = a.rstrip('ax')
 d = a.strip('ax')
 print(b)#tangxa
 print(c)#axtang
 print(d)#tang

 # maketrans() translate() 自定义替换,两个函数配套使用
 st = "ajketjaeoijmdgajtyopayjhpaeg"
 a = str.maketrans("aeiou","") # a=1,e=2,i=3,o=4,u=5
 at = st.translate(a)
 print(at) # 1jk2tj1243jmdg1jty4p1yjhp12g

 # partition() 分割,分成三部分成元组，可以拿到sep
 # partition(self, sep)
 a = 'tanglaoer'
 b = a.partition('a')
 c = a.partition('ao')
 d = a.partition('r')
 print(b) # ('t', 'a', 'nglaoer')
 print(c) # ('tangl', 'ao', 'er')
 print(d) # ('tanglaoe', 'r', '')

 # split() lsplit() rsplit() # 分割,按sep分割成列表，不可以拿到sep
 # split(self, sep=None, maxsplit=-1) maxsplit=分割次数
 a = 'tanglaoer'
 b = a.split('a')
 c = a.rsplit('a',1)
 print(b) # ['t', 'ngl', 'oer']
 print(c) # ['tangl', 'oer']

 # splitlines() 分割
 # splitlines(self, keepends=None) keepends=True | False
 a = "aldgjal\najlkgjal\nalgladjg"
 b = a.splitlines(False)
 c = a.splitlines(True)
 print(b) # ['aldgjal', 'ajlkgjal', 'algladjg']
 print(c) # ['aldgjal\n', 'ajlkgjal\n', 'algladjg']

 # startswith() 以什么开头
 # startswith(self, prefix, start=None, end=None)
 a = "tanglaoer"
 b = a.startswith('a')
 c = a.startswith('a',1)
 print(b) # False
 print(c) # True

 # replace() 替换
 # replace(self, old, new, count=None) count=替换的次数
 a = "tanglaoer"
 b = a.replace("a","T")
 c = a.replace("a","T",1)
 print(b) #tTnglToer
 print(c) #tTnglaoer

 # ******************************以下必须知道的***************
 # 获取字符串中的某一个
 # 通过索引，下标
 a = 'tanglaoer'
 b = a[2]
 print(b) # n

 # 通过[M:n]切片 -1:表示最后一个
 a = 'tanglaoer'
 b = a[0:1] #[0,1)
 c = a[0:-1] #[0,-1)
 print(b) # t
 print(c) # tanglaoe

 # len() 求长度
 a = 'tanglaoer'
 c = '唐老二'
 b = len(a)
 d = len(c)
 print(b) #
 print(d) # 3 注意: 在python2中拿到的是9

 # for 循环取值
 a = 'tanglaoer'
 for i in a:
     print(i,end=' ') #t a n g l a o e r
 print()

 # 字符串拼接
 """
 内存理解： 字符串是不可变类型
 1.首先a申请一块内存存放"tanglaoer"
 2.b申请一块内存存放"18"
 3.c重新申请一块内存放"tanglaoer18"
 """
 a = "tanglaoer"
 b = ""
 c = a + b
 print(c) # tanglaoer18

布尔值 bool

a = bool(12)
print(a) # True

a = True
print(a) # True

a = False
print(a) # False

# 为False的值
# "" () [] {} 0 None

列表 list

__author__ = "Tang"

# 列表中的元素 数字，字符串，列表，布尔值...
li = [1, 'age', ['tang', ['lao', 'er']], True]

# 索引取值
print(li[1])  # age
print(li[2][0])  # tang

# 切片 取值
print(li[2:-1])  # [['tang', ['lao', 'er']]]

# for循环 while 循环 取值
# for item in li:
#     print(item)

# 列表元素，可以被修改 是可变类型
li = [1, 'age', ['tang', ['lao', 'er']], True]
# 索引修改
li[0] = 20
print(li[0])

#  删除
del li[1]
print(li)  # [20, ['tang', ['lao', 'er']], True]

# 切片 修改多个值
li = [1, 12, 9, 'age', ['tang', ['lao', 'er']], True]
li[1:3] = [120, 90]
print(li)  # [1, 120, 90, 'age', ['tang', ['lao', 'er']], True]

# 切片 删除多个值
li = [1, 12, 9, 'age', ['tang', ['lao', 'er']], True]
del li[2:6]
print(li)  # [1, 12]

# in 操作
li = [1, 12, 9, 'age', ['tang', ['lao', 'er']], True]
v = "age" in li
print(v)  # True

v = 'tang' in li
print(v)  # False

v = ['tang', ['lao', 'er']] in li
print(v)  # True

# 取值操作
li = [1, 12, 9, 'age', ['tang', ['lao', 'er']], True]
print(li[3][1])  # g
print(li[4][1][0])  # lao

# 数字 字符串转换
a = ""
s = int(a)
print(s, type(s))  # 123 <class 'int'>

a = 123
s = str(a)
print(s, type(s))  # 123 <class 'str'>

# 字符串转换成列表
s = "tanglaoer"
new_li = list(s)  # 内部使用for循环
print(new_li)  # ['t', 'a', 'n', 'g', 'l', 'a', 'o', 'e', 'r']

# 列表转换成字符串
li = [11, 22, 33, "", "tang", True]
r = str(li)
print(r)  # [11, 22, 33, '123', 'tang', True]

# 列表转换成字符串 第一种 失败
li = [11, 22, 33, "", "tang", True]
s = ""
li = str(li)  # 每一个字符是一个元素 11就代表两个元素 包括[]号也是元素
for i in li:
    print(i)
    """
    [
1
1
,

2
2
,

3
3
,

'
1
2
3
'
,

'
t
a
n
g
'
,

T
r
u
e
]
"""
    s += i
print(s)  # [11, 22, 33, '123', 'tang', True]

# 列表转换成字符串 第二种 有点麻烦
li = [11, 22, 33, "", "tang", True]
s = ""
for i in li:
    s = s + str(i)
print(s)  # 112233123tangTrue

# 列表转换成字符串 第三种 完美
li = [11, 22, 33, "", "tang", True]

# 因为列表里面有整型 不能直接转换为字符串
# s = "".join(li) # 报错 TypeError: sequence item 0: expected str instance, int found
s = "".join('%s' % i for i in li)
print(s)  # 112233123tangTrue

# 这个很重要 列表 元组 字符串 使用切片【M:N】取值 超出边界不报错
# 如果是根据【n】索引取值，就会报错
# li = [1,2,3,4,5,6,7]
# tt = li[10:]
# print(tt) # []
# print(tt[10]) # 报错

# st = "tanglaoer"
# st2 = st[10:]
# st3 = st[1:]
# print(st2) # 空格
# print(st3) # anglaoer
# print(st[20]) 报错

# tup = (1,2,3,4,5,)
# tup2 = tup[10:]
# tup3 = tup[10]
# print(tup2) # 空格
# print(tup3) # 报错

##############list 方法#################

# append() 追加
li = [11, 22, 33, 44]
v = li.append(55)
print(v)  # None
print(li)  # [11, 22, 33, 44, 55]

# clear() 清空
li = [11, 22, 33, 44]
v = li.clear()
print(v)  # None
print(li)  # []

# copy() 浅拷贝
li = [11, 22, 33, 44]
v = li.copy()
print(v)  # [11, 22, 33, 44]
print(li)  # [11, 22, 33, 44]

# count() 统计
li = [11, 22, 33, 44]
v = li.count(22)
print(v)  #
print(li)  # [11, 22, 33, 44]

# extend() 扩展
# extend(self, iterable) iterable=可迭代对象(字符串 列表 元组）
li = [11, 22, 33, 44]
v = li.extend(['a', 'b', 'c', 90, 50, 'tang'])
v2 = li.extend('tanglaoer')
print(v)  # None
print(li)  # [11, 22, 33, 44, 'a', 'b', 'c', 90, 50, 'tang', 't', 'a', 'n', 'g', 'l', 'a', 'o', 'e', 'r']
print(v2)  # None

"""
append() & extend() 的区别:
1. append() 参数如果是可迭代对象，不会循环取值，而是当做整体插入
2. extend() 循环取值，一个一个的插入
"""

# index() 寻找索引
# index(self, value, start=None, stop=None)
li = [11, 22, 33, 22, 44]
v = li.index(22)
v2 = li.index(22, 2)
print(v)  #
print(v2)  #

# insert() 在指定位置插入值
# insert(self, index, p_object)
li = [11, 22, 33, 44]
v = li.insert(3, 22)
print(v)  # None
print(li)  # [11, 22, 33, 22, 44]

# pop() 删除某索引并返回其位置的值 默认删除最后一个
# pop(self, index=None)
li = [11, 22, 33, 44]
v = li.pop(2)
v2 = li.pop()
print(v)  #
print(v2) #
print(li)  # [11, 22]

# remove() 删除某一个值
# remove(self, value)  左边优先
li = [11, 22, 33, 44]
v = li.remove(22)
print(v)  # None
print(li)  # [11, 33, 44]

# del() 删除
li = [11, 22, 33, 44]
del li[0]
print(li)  # [22, 33, 44]
del li[0:1]
print(li) # [33, 44]

"""
pop() & remove() & clear() & del
1. pop() 参数为索引下标
2. remove() 参数为值
3. clear() 清空所有
4. del 删除某指定的位置，也可以切片
"""

# reverse() 将当前列表进行反转
li = [11, 22, 33, 44]
v = li.reverse()
print(v) # None
print(li) # [44, 33, 22, 11]

# sort() 排序
# sort(self, key=None, reverse=False) 默认从小到大排序
li = [11, 22, 33, 44]
v = li.sort()
print(v) # None
print(li) # [11, 22, 33, 44]

v2 = li.sort(reverse=True) # 从大到小排序
print(v2) # None
print(li) # [44, 33, 22, 11]

# 查看地址
li = [11, 22, 33, 44]
print(li ,id(li)) # [11, 22, 33, 44] 50110832

li.append(55)
print(li,id(li)) # [11, 22, 33, 44, 55] 50110832

# 列表是可变类型
li = [11, 22, 33, 44]
print(li[0]) #
li[0] = 99
print(li[0]) #

# 字符串是不可变类型
s = "tanglaoer"
s[0] = 'B'
print(s[0]) # 报错

元组 tuple

__author__ = "Tang"

# 元组 元素不可被修改
tu = (111, 22, 33, 44,)
# tu[0] = 999 # 报错
# del tu[0] # 报错
print(tu)  # (111, 22, 33, 44)

# 在最后多加一个逗号 区别于方法 整型 不加也不报错
l = (11)
print(l)  # 11  整型

l2 = (11,)
print(l2)  # (11,) 元组

tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)
print(tu)  # (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

# 索引取值
tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)
v = tu[0]
print(v) #

# 切片取值
tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)
v = tu[0:3]
print(v) # (111, 'tang', (1, 2, 3))

# 循环取值 是可迭代对象
# tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)
# for i in tu:
#     print(i)
"""
111
tang
(1, 2, 3)
[4, 5, 6]
True
45
"""

# 元组转列表
tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)
tu = list(tu)
print(tu) # [111, 'tang', (1, 2, 3), [4, 5, 6], True, 45]

# 列表转元组
li = [111, 'tang', (1, 2, 3), [4, 5, 6], True, 45]
tu = tuple(li)
print(tu) # (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)

# 字符串转元组
s = "tanglaoer"
tu = tuple(s)
print(tu) # ('t', 'a', 'n', 'g', 'l', 'a', 'o', 'e', 'r')

# 元组转字符串第一种 元组不仅仅是字符串 只能自己写for循环
tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)
v = "".join("%s"%str(i) for i in tu)
print(v,type(v)) # 111tang(1, 2, 3)[4, 5, 6]True45 <class 'str'>

# 元组转字符串第二种 元组都是字符串
tu = ('tang','lao','er',)
v = "".join(tu)
print(v) # tanglaoer

# 元组 列表都是有序的
tu = (111, 'tang', (1, 2, 3), [4, 5, 6], True, 45)
v = tu[2][2]
print(v) #

# 元组里面的一级元素不可以修改/删除/增加  二级元素可以修改
tu = (111, 'tang', (1, 2, 3), [4, 5, 6,(33,44)], True, 45)
print(tu[3][0]) #
tu[3][0] = 14
print(tu[3][0]) #

print(tu[3][3]) # (33, 44)
tu[3][3] = 8989
print(tu[3][3]) #

##########################tuple  方法##########

# count() 获取指定元素的个数
tu = (111, 'tang', (1, 2, 3), [4, 5, 6,(33,44)], True, 45, 45,65,45)
v = tu.count(45)
print(v) #

# index() 获取指定元素的索引下标
# index(self, value, start=None, stop=None)
tu = (111, 'tang', (1, 2, 3), [4, 5, 6,(33,44)], True, 45, 45,65,45)
v = tu.index(45)
print(v) #

字典 dict

__author__ = "Tang"

# 键值对 dict
a = {
    'a': 1,
    'b': 2,
    'c': 3
}
print(a)  # {'a': 1, 'b': 2, 'c': 3}

info = {
    "key0": True,
    "key1": 10,
    "key2": 20,
    "key3": 30,
    "key4": [11, 22, 33],
    "key5": (44, 55, 66,),
    "key6": {'k0': 'v0', 'k1': 'v1', 'k2': 'v2'}
}
print(info)
"""
{'key0': True, 'key1': 10, 'key2': 20, 'key3': 30, 'key4': [11, 22, 33], 'key5': (44, 55, 66), 'key6': {'k0': 'v0', 'k1': 'v1', 'k2': 'v2'}}
"""
# 通过上面例子可以知道 value 可以是任意类型
# 字典的key 可以是整型 字符串 元组 布尔 而列表跟字典可变数据类型不可以当key
tt = {
    2: '',
    'st': 'st',
    True: "",
    (11, 22,): (11, 22)
}
print(tt)  # {2: '1', 'st': 'st', True: '123', (11, 22): (11, 22)}

# 字典是无序的 不可以通过索引取值 切片
# dt = {'a': 1, 'b': 2, 'c': 3}
# print(dt[1]) # 报错

# 通过key取值
dt = {'a': 1, 'b': 2, 'c': 3}
print(dt['a'])  #

#  删除
dt = {'a': 1, 'b': 2, 'c': 3}
del dt['a']
print(dt)  # {'b': 2, 'c': 3}

# 循环取值
info = {
    "key0": True,
    "key1": 10,
    "key2": 20,
    "key3": 30,
    "key4": [11, 22, 33],
    "key5": (44, 55, 66,),
    "key6": {'k0': 'v0', 'k1': 'v1', 'k2': 'v2'}
}
for item in info:  # 默认是取键
    print(item)
    """
key0
key1
key2
key3
key4
key5
key6
    """

for item in info.keys():  # 取键
    print(item)

for item in info.values():  # 取值
    print(item)

for k, v in info.items():  # 取键 & 值
    print(k, v)

# 字典的键要唯一 如果重复只显示第一个 注意：True=1 False=0
test = {1: '', True: ''}
print(test)  # {1: '1'}

test = {2: '', True: ''}
print(test)  # {2: '1', True: '1'}

################# dict 的方法
# fromkeys() 类的静态方法
# fromkeys(*args, **kwargs)
v = dict.fromkeys([11, 22, 33])
print(v)  # {11: None, 22: None, 33: None}

v = dict.fromkeys([11, 22, 33], ['a', 'b'])
print(v)  # {11: ['a', 'b'], 22: ['a', 'b'], 33: ['a', 'b']}

# 通过索引取值，如果键不存在就报错
# 用get函数取值，不存在不报错，并且可以指定默认值
# get() 取值
dt = {'a': 1, 'b': 2, 'c': 3}
v = dt.get('a',99)
print(v) #

v = dt.get('z',99) # 如果不存在，取第二个参数的值
print(v) #

# pop() 删除
dt = {'a': 1, 'b': 2, 'c': 3}
v = dt.pop('a',99)
print(v) #

v = dt.pop('z',99) # 键不存在 得到默认值
print(v) #

# popitem() 随机删除一个
dt = {'a': 1, 'b': 2, 'c': 3}
v = dt.popitem() # 删除并返回一个元组
print(v) # ('c', 3)

k,v = dt.popitem()
print(k,v) # b 2

# setdefault() 键已经存在，不设置并获取已存在的值，键不存在，就设置并取当前设置的值
dt = {'a': 1, 'b': 2, 'c': 3}
v = dt.setdefault('a','')
print(v) #
print(dt) # {'a': 1, 'b': 2, 'c': 3}

v = dt.setdefault('z','')
print(v) #
print(dt) # {'a': 1, 'b': 2, 'c': 3, 'z': '10'}

# update() 更新
dt = {'a': 1, 'b': 2, 'c': 3}
dt.update({'a':'','z':''})
print(dt) # {'a': '10', 'b': 2, 'c': 3, 'z': '100'}

dt.update(k=123,k2=456,k3="")
print(dt) # {'a': '10', 'b': 2, 'c': 3, 'z': '100', 'k': 123, 'k2': 456, 'k3': '789'}

"""
必会： keys() values() get() update() items()
"""

整理常用的

__author__ = "Tang"

"""常用的"""

# 整型
# int()

# 字符串
# replace/find/join/strip/startswith/split/upper/lower/format
tempate = "my name is {name},hobby is {hobby}"
v = tempate.format(name='tang',hobby='游戏')
print(v) # my name is tang,hobby is 游戏

v = tempate.format(**{'name':'tang','hobby':'游戏'})
print(v) # my name is tang,hobby is 游戏

# 列表
# append/extend/insert
# 索引、切片、循环 取值

# 元组
# count/index

# 字典
# get/update/keys/values/items/fromkeys

可变与不可变类型

__author__ = "Tang"

"""
可变与不可变类型
可变类型:修改变量的值，id不变---->列表，字典
不可变类型:修改变量的值，id改变--->  字符串，数字，元组
"""

# 字符串 修改变量的值，id改变
name = "tang"
print(id(name)) #
name = "tang2"
print(id(name)) #

# 数字 修改变量的值，id改变
age = 18
print(id(age)) #
age = 19
print(id(age)) #

# 列表 修改变量的值，id不变
age = [18,19]
print(id(age)) #
age[1] = 90
print(id(age)) #

# 字典 修改变量的值，id不变
dic = {"age":18,"name":"tang"}
print(id(dic)) #
dic["age"] = 90
print(id(dic)) #

集合

__author__ = "Tang"

"""
集合
1.不同元素组成
2.无序
3.集合中元素必须是不可变类型
"""
s = {1,2,3,4,5}
print(s) # {1, 2, 3, 4, 5}

# 自动去重
s = {1,2,3,4,5,3,3,2,1}
print(s) # {1, 2, 3, 4, 5}

# 无序的
s = {'hello','world','tang'}
for i in s:
    print(i,end=" ") # hello tang world

# 元素必须是不可变类型
# s = {[1,2,3],"tang"}
# print(s) # 报错

# 字符串转集合
s = set('hello')
print(s,end=" ") # {'l', 'h', 'o', 'e'}

# 列表转集合
s = set(['tang','lao','er'])
print(s) # {'er', 'tang', 'lao'}

##############set 方法##############
# add()添加
s = {1,2,3,4,5,6}
s.add('s')
print(s) # {1, 2, 3, 4, 5, 6, 's'}

# clear() 清空
s = {1,2,3,4,5,6}
s.clear()
print(s) # set()

# copy() 拷贝
s = {1,2,3,4,5,6}
s1 = s.copy()
print(s1) # {1, 2, 3, 4, 5, 6}

# pop() 随机删除一个并返回其值
s = {1,2,3,4,5,6}
s1 = s.pop()
print(s) # {2, 3, 4, 5, 6}
print(s1) #

# remove() 指定删除，如果不存在就报错
s = {1,2,3,4,5,6}
s1 = s.remove(1)
# s.remove('s') # 报错
print(s) # {2, 3, 4, 5, 6}
print(s1) # None

# discard() 指定删除,不存在也不会报错
s = {1,2,3,4,5,6}
s1 = s.discard(1)
s.discard('s') # 不报错
print(s) # {2, 3, 4, 5, 6}
print(s1) # None

# 集合去重不会遵守原来序列的顺序
a = ['a','t','b','a','t','g','h']
a = set(a)
print(a) # {'g', 'a', 't', 'h', 'b'}
a = list(a)
print(a) # ['g', 'a', 't', 'h', 'b']

# 交集 intersection()  &
a = ['tang','lao','er']
b = ['tang','chen','lao','er','san']
p_a = set(a)
p_b = set(b)
a_and_b = p_a.intersection(p_b)
print(a_and_b) # {'lao', 'tang', 'er'}

a_and_b2 = p_a & p_b
print(a_and_b2) # {'lao', 'tang', 'er'}

# 并集 union() |
a = ['tang','lao','er']
b = ['tang','chen','lao','er','san']
p_a = set(a)
p_b = set(b)
a_or_b = p_a.union(p_b)
print(a_or_b) # {'san', 'lao', 'tang', 'er', 'chen'}

a_or_b2 = p_a | p_b
print(a_or_b) # {'san', 'lao', 'tang', 'er', 'chen'}

# 差集 difference() -
a = ['tang','lao','er','susu']
b = ['tang','chen','lao','er','san']
p_a = set(a)
p_b = set(b)
a_b = p_a.difference(p_b)
print(a_b) # {'susu'}

a_b2 = p_a - p_b
print(a_b2) # {'susu'}

# 交叉补集 总的减去共同的部分  symmetric_difference() ^
a = ['tang','lao','er','susu']
b = ['tang','chen','lao','er','san']
p_a = set(a)
p_b = set(b)
a_b = p_a.symmetric_difference(p_b)
print(a_b) # {'san', 'chen', 'susu'}

a_b = p_a ^ p_b
print(a_b) # {'san', 'chen', 'susu'}

# difference_update() 删除相同的 留下不同的
a = ['tang','lao','er','susu']
b = ['tang','chen','lao','er','san']
p_a = set(a)
p_b = set(b)
a_b = p_a.difference_update(p_b) # 减去相同的 并更新赋值
print(a_b) # None
print(p_a) # {'susu'}

# isdisjoint() 判断是否为无共同部分的
a = {'a','b','c'}
b = {'e','f'}
print(a.isdisjoint(b)) # True

# issubset() 判断是否为子集
a = {'a','b','c'}
b = {'a','b'}
print(b.issubset(a)) # True
print(a.issubset(b)) # False

# issuperset() 判断是否为父集
a = {'a','b','c'}
b = {'a','b'}
print(b.issuperset(a)) # False
print(a.issuperset(b)) # True

# update() 更新多个值，元组，列表，集合都可以
a = {'a','b','c'}
b = {'e','f'}
b.update(a)
print(b) # {'b', 'e', 'c', 'f', 'a'}
b.update((1,2,3))
print(b) # {'c', 1, 2, 'a', 3, 'b', 'e', 'f'}
b.update([4,5,6])
print(b) # {1, 2, 3, 4, 5, 6, 'f', 'c', 'a', 'b', 'e'}

"""
update() 与 add() 比较：
1.update() 可以添加多个值，参数可以是可迭代数据类型
2.add() 只能添加一个元素

可迭代类型:
可以for循环遍历的就是可迭代类型
"""

# frozenset() 定义为不可变集合
s = frozenset('hello')
print(s) # frozenset({'l', 'o', 'h', 'e'})
for i in s:
    print(i,end=" ") # h o e l