标签：哈希表 app pre 需要 tar 屌丝 清空 培训机构 super
基础数据类型
整数（int），字符串（str），布尔值（bool），列表（list），元祖（tuple），字典（dict），集合（set）。
数字int
#bit_length() 当十进制用二进制表示时，最少使用的位数 v = 11 data = v.bit_length() print(data)
布尔值bool
真 1 True
假 0 False
i = bool(3) print (i) # True i = bool(0) # False print (i) i = int (True) print (i) # 1 i = int (False) print (i) # 0 if 1 : print (‘aaaa‘) # aaaa
字符串str
字符串的索引和切片
索引即下标，就是字符串组成元素的第一个开始，初始索引以0开始，以此类推。
s = ‘alex wusir ritian qwertyuiopasdfgghjkl;zxcvbnm‘ s1 = s[0] print (s1,type(s1)) s2 = s[2] print (s2,type(s2)) s3 = s[-1] print (s3) s4 = s[-2] print (s4) # 切片：顾头不顾尾 s5 = s[0:4] print (s5) s6 = s[2:6] print(s6) s7 = s[5:] print (s7) s8 = s[0:] # 默认到最后 print (s8) s9 = s[:] print (s9)
s = ‘alex wusir ritian qwertyuiopasdfgghjkl;zxcvbnm‘ # [起始索引：终止索引：步长] s10 = s[0:3:2] print (s10) # ae # 倒叙取 s11 = s[-1:-6:-2] print (s11) # mbc s12 = s[3:0:-2] print (s12) # xl s13 = s[2::-2] print(s13) # ea
字符串常用方法
字母大小写
#title()非字母隔开的部分，首字母大写，其他小写 s = ‘alex wuSir1taibai*ritian‘ print(s.title()) print (s.upper()) #全部大写 print (s.lower()) #全部小写 code = (‘dErF‘) you_code = input(‘请输入你的验证码：‘) if you_code.upper() == code.upper(): print (‘输入正确‘) else: print (‘输入错误‘)
#captalize,swapcase,title print(name.capitalize()) #首字母大写 print(name.swapcase()) #大小写翻转 msg=‘egon say hi‘ print(msg.title()) #每个单词的首字母大写 # 内同居中，总长度，空白处填充 ret2 = a1.center(20,"*") print(ret2) #数字符串中的元素出现的个数。 # ret3 = a1.count("a",0,4) # 可切片 # print(ret3) a2 = "hqw\t" #\t前面的补全 # 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。 ret4 = a2.expandtabs() print(ret4) a4 = "dkfjdkfasf54" #startswith 判断是否以...开头 #endswith 判断是否以...结尾 # ret4 = a4.endswith(‘jdk‘,3,6) # 顾头不顾腚 # print(ret4) # 返回的是布尔值 # ret5 = a4.startswith("kfj",1,4) # print(ret5) #寻找字符串中的元素是否存在 # ret6 = a4.find("fjdk",1,6) # print(ret6) # 返回的找到的元素的索引，如果找不到返回-1 # ret61 = a4.index("fjdk",4,6) # print(ret61) # 返回的找到的元素的索引，找不到报错。 #split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。 # ret9 = ‘title,Tilte,atre,‘.split(‘t‘) # print(ret9) # ret91 = ‘title,Tilte,atre,‘.rsplit(‘t‘,1) # print(ret91) #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) #strip name=‘*egon**‘ print(name.strip(‘*‘)) print(name.lstrip(‘*‘)) print(name.rstrip(‘*‘)) #replace name=‘alex say :i have one tesla,my name is alex‘ print(name.replace(‘alex‘,‘SB‘,1)) #####is系列 name=‘jinxin123‘ print(name.isalnum()) #字符串由字母或数字组成 print(name.isalpha()) #字符串只由字母组成 print(name.isdigit()) #字符串只由数字组成
join的一个用法
s = ‘alexwusir‘ s1 = ‘ ‘.join(s) print (s1) # a l e x w u s i r
加法计算器
# 实现一个整数加法计数器：如： # count = input(‘请输入内容：‘） #如用户输入：5+9 或 5+ 9 或 5 + 9，然后进行分割再计算 方法1： count = input (‘请输入内容：‘) sum = 0 count = count.split(‘+‘) for i in count: sum = sum + int(i) print (sum) 方法2： count = input(‘请输入内容：‘) sum = 0 index = count.find(‘+‘) l1 = count[0:index] l2 = count[index+1:] sum = int(l1) + int(l2) print (sum)
计算用户输入的内容有几个整数
#计算用户输入的内容中有几个整数 #如：content = inpute(‘请输入内容：’）， count = input(‘请输入内容：‘) sum = 0 for i in count: if i.isdigit(): sum += 1 print (sum)
元祖stuple
元祖被称为只读列表，即数据可以被查询，但是不能被修改，所以，字符串的切片操作同样适用于元祖。
#元组 #tuple tu = (1,2,‘wusir‘,‘taibai‘,[1,2,3],True) l = [1,2,3,True] for i in tu: print (i) print (tu[2:]) #儿子不能更改，但是孙子有可能更改 tu1 = (1,2,‘wusir‘,[1,2,3],[2,3,4],‘taibai‘,True) tu1[3].pop(1) print (tu1) tu1[3].append(‘taibai‘) print (tu1) print (len(tu1)) print (tu1.count(1)) print (l.count(1)) print (tu1.index(‘wusir‘)) #range 当作：范围列表[]，列表中的元素是数字，且可控的有效数字范围 #一般与for配合使用 for i in range(1,10): print (i) for i in range(1,101): print (i) for i in range(11): print (i) for i in range(1,10,2): print (i) for i in range(10,0,-1): print (i) for i in range(10,-2,-1): print (i) l1 = [1,2,3,‘alex‘,[2,3,‘wusir‘],7] for i in l1: if type(i) == list: for j in i: print (j) else: print (i)
列表list
列表是Python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组。
列表是有序的，有索引值，可切片，方便取值。
增
li = [1,‘a‘,‘b‘,2,3,‘a‘] # li.insert(0,55) #按照索引去增加 # print(li) # # li.append(‘aaa‘) #增加到最后 # li.append([1,2,3]) #增加到最后 # print(li) # # li.extend([‘q,a,w‘]) #迭代的去增 # li.extend([‘q,a,w‘,‘aaa‘]) # li.extend(‘a‘) # li.extend(‘abc‘) # li.extend(‘a,b,c‘) # print(li) l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2] while True: username = input(‘请输入你的名字：(q或Q退出)‘) if username.upper() == ‘Q‘:break l1.append(username) print (l1)
删
# 删除 pop l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2] l1.pop() #默认删除最后一个 print(l1) ret = l1.pop(4) print (ret) print (l1) # remove 按照元素去删 ret = l1.remove(‘alex‘) print (l1) print (ret) # clear 清空列表 l1.clear() print (l1) # del 功能1：删除列表 del l1 print (l1) # 功能2：可以按切片，按索引去删除 l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2] del l1[0] print (l1) del l1[0:3] print (l1) del l1[1::2] print (l1)
改
l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2] # 按照索引去改 l1[0] = ‘男神‘ print (l1) # [‘男神‘, True, ‘wusir‘, ‘ritian‘, ‘taibai‘, 3, 2] # 按照切片去改 l1[0:2] = [‘屌丝‘,‘alex‘] print (l1) # [‘屌丝‘, ‘alex‘, ‘wusir‘, ‘ritian‘, ‘taibai‘, 3, 2] l1[0:2] = [‘ 屌丝，alex‘] print(l1) # [‘ 屌丝，alex‘, ‘wusir‘, ‘ritian‘, ‘taibai‘, 3, 2]
查
# 按切片，按索引去查 l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2] print (l1[0]) print (l1[0:3]) # for 循环查 for i in l1: print (i)
其它操作
# len 长度 l1 = [1,2,3,4,5,6,7,8] print (len(l1)) # count 出现次数 print (l1.count(1)) # index 通过元素找索引 print (l1.index(1)) # sort 从小到大 l1 = [1,4,7,3,8,5,9,3] # l1.sort() # print (l1) # sort(reverse) 从大到小 l1.sort(reverse=True) print(l1) # reverse 倒叙 l1.reverse() print (l1)
字典dict
字典是Python中唯一的映射类型，采用键值对（key-value）的形式存储数据。Python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变数据类型，如：数字、字符串、元祖
字典（dictionary）是除列表以外Python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
增
# dic[‘li‘] = ["a","b","c"] # print(dic) # setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。 # dic.setdefault(‘k‘,‘v‘) # print(dic) # {‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘} # dic.setdefault(‘k‘,‘v1‘) # {‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘} # print(dic)
删
# dic_pop = dic.pop("a",‘无key默认返回值‘) # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值 # print(dic_pop) # del dic["name"] # 没有返回值。 # print(dic) # dic_pop1 = dic.popitem() # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回 # print(dic_pop1) # (‘name‘,‘jin‘) # dic_clear = dic.clear() # 清空字典 # print(dic,dic_clear) # {} None
改
# 改 # dic = {"name":"jin","age":18,"sex":"male"} # dic2 = {"name":"alex","weight":75} # dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中 # print(dic2)
查
# value1 = dic["name"] # 没有会报错 # print(value1) # # value2 = dic.get("djffdsafg","默认返回值") # 没有可以返回设定的返回值 # print(value2)
其他操作
# item = dic.items() # print(item,type(item)) # dict_items([(‘name‘, ‘jin‘), (‘sex‘, ‘male‘), (‘age‘, 18)]) <class ‘dict_items‘> # 这个类型就是dict_items类型，可迭代的 # keys = dic.keys() # print(keys,type(keys)) # dict_keys([‘sex‘, ‘age‘, ‘name‘]) <class ‘dict_keys‘> # values = dic.values() # print(values,type(values)) # dict_values([‘male‘, 18, ‘jin‘]) <class ‘dict_values‘> 同上
字典的循环
# dic = {"name":"jin","age":18,"sex":"male"} # for key in dic: # print(key) # for item in dic.items(): # print(item) # for key,value in dic.items(): # print(key,value)
集合
集合是无序的，不重复的数据集合，它里面的元素是可哈希的（不可变类型），但是集合本事是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就可以自动去重了。
关系测试，测试两组数据之间的交集、差集、并集等关系。
1. 集合的创建
set1 = set({1,2,‘barry‘})
set2 = {1,2,‘barry‘}
print(set1,set2) # {1, 2, ‘barry‘} {1, 2, ‘barry‘}
2. 集合的增
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.add(‘景女神‘)
print(set1)
#update：迭代着增加
set1.update(‘A‘)
print(set1)
set1.update(‘老师‘)
print(set1)
set1.update([1,2,3])
print(set1)
3. 集合的删
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.remove(‘alex‘) # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
print(set1)
4. 集合的其他操作：
4.1 交集（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
4.2 并集（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}
4.3 差集（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
4.4 反交集 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
4.5 子集和超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
5. frozenset不可变集合，让集合变成不可变类型
s = frozenset(‘barry‘) print(s,type(s)) # frozenset({‘a‘, ‘y‘, ‘b‘, ‘r‘}) <class ‘frozenset‘>
三、基础数据类型的总结
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息
元祖：有序，需要存索引相关信息，不可变
列表：有序，需要存索引有关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射相关关系，可变，需要处理数据的增删改
按存值个数区分
标量/原子类型：数字，字符串
容器类型：列表，元祖，字典
按可变不可变区分：
可变：列表
不可变：数字，字符串，元祖，布尔值
按访问顺序区分
直接访问：数字
顺序访问（序列类型）：字符串，列表，元祖
key值访问（映射类型）：字典
四、其他（for，enumerate，range）
for循环：用户按照顺序循环可以迭代对象的内容
msg = ‘老男孩python是全国范围内最好的python培训机构‘ for item in msg: print(item) li = [‘alex‘,‘银角‘,‘女神‘,‘egon‘,‘太白‘] for i in li: print(i) dic = {‘name‘:‘太白‘,‘age‘:18,‘sex‘:‘man‘} for k,v in dic.items(): print(k,v)
enumerate：枚举，对于一个可迭代的（iterable）、可遍历的对象（如列表，字符串）
enumerate将其组成一个索引序列，利用它可以同时获得索引和值
li = [‘alex‘,‘银角‘,‘女神‘,‘egon‘,‘太白‘] for i in enumerate(li): print(i) for index,name in enumerate(li,1): print(index,name) for index, name in enumerate(li, 100): # 起始位置默认是0，可更改 print(index, name)
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)
标签：哈希表 app pre 需要 tar 屌丝 清空 培训机构 super
原文地址：https://www.cnblogs.com/Big-Dinosaur/p/9948339.html
