Python 基本数据类型

  1 test = "zzHou"
  2 
  3 # 首字母大写
  4 print(test.capitalize())
  5 
  6 # 变小写，casefold更厉害可以出来未知对应关系
  7 print(test.casefold())
  8 print(test.lower())
  9 
 10 #center 设置宽度，并将内容居中 20代指宽度，*代指填充字符只能有一个
 11 #还有 左边填充 ljust 右边填充 rjust
 12 #zfill 只能用0填充
 13 print(test.center(20, "*"))
 14 
 15 #去字符串中寻找子序列出现的个数，起始位置5 结束位置6都是可选的
 16 print(test.count("zz",5,6))
 17 
 18 #以什么什么结尾起始位置5 结束位置6都是可选的
 19 print(test.endswith("ou",5,6))
 20 
 21 #以什么什么开头起始位置5 结束位置6都是可选的
 22 print(test.startswith("zz",5,6))
 23 
 24 #将tab符转换成空格，默认是8个,返回当前字符串的副本,先断句，不足位的从前一位补足
 25 print("z\thou".expandtabs())
 26 print("123456\t789".expandtabs(6))
 27 print("1\t3456789".expandtabs(6))
 28 
 29 #find 从头开始找，找到返回索引，找不到返回-1.[2,8)之间且只找一次
 30 #index 找不到会报错
 31 print(test.find("H",2,8))
 32 
 33 #format 格式化，按顺序或者名称替换占位符
 34 print("我是{name}，age{a}".format(name="zhou", a=19))
 35 print("我是{0}，age{1}".format("zhou", 19))
 36 
 37 #format_map
 38 #format 使用字典进行格式化
 39 print("我是{name}，age{a}".format_map({"name": '周航', "a": 19}))
 40 
 41 #isalnum 是否是字母和数字
 42 print(test.isalnum())
 43 
 44 #isalpha 是否是字母
 45 print("abc".isalnum())
 46 
 47 isdecimal isdigit isnumeric是否是数字 isdigit更厉害比如“②” isnumeric 支持中文
 48 test = "123"
 49 v1 = test.isdecimal()
 50 v2 = test.isdigit()
 51 v3 = test.isnumeric()
 52 print(v1,v2)
 53 
 54 isidentifier 是否是合法标示符
 55 a = "str"
 56 print(a.isidentifier())
 57 
 58 # isprintable   是否存在不可显示的字符 比如字符串中的\t
 59 print("org\tsss".isprintable())
 60 print("    ".isprintable())
 61 
 62 #isspace() 是否全部是空格
 63 
 64 #istitle() 是否是标题   每个单词首字母都是大写 可以跟title()连用
 65 print("ni shif eng re".title())    #Ni Shif Eng Re
 66 print("Ni Shif Eng Re".istitle())  #True
 67 
 68 #*****************join() 字符串每个字符按照指定分隔符拼接******************
 69 print(" ".join("我我我欧文"))   #我 我 我 欧 文
 70 print("&".join("我我我欧文"))   #我&我&我&欧&文
 71 
 72 #islower() lower() 判断是小写 转换成小写
 73 test = "Zhou"
 74 v1 = test.lower()
 75 v2 = test.islower()
 76 print(v1,v2)
 77 
 78 #isupper() upper() 判断是大写 转换成大写
 79 
 80 #lstrip() rstrip() strip() 去除左(\t,\r)、右，全部空格 还可以加入参数，尽量多的匹配需要去除的字符
 81 
 82 
 83 #S.strip([chars]) -> str
 84 
 85 #Return a copy of the string S with leading and trailing
 86 #whitespace removed.
 87 #If chars is given and not None, remove characters in chars instead.
 88 
 89 
 90 test = "9lexxexa"
 91 v = test.rstrip('xa')
 92 print(v)
 93 
 94 #str.maketrans("abc","123")  abc和123 映射替换
 95 
 96 test = "testaasa"
 97 #partition()   按照字符串分割成三份 test.partition("s")  te s taasa
 98 #rpartition()   按照字符串分割成三份 test.rpartition("s")  testaa s a
 99 #split() test.split('s') te taa a  可以加入一个参数 指定分割次数，但是s不会留下 后面有正则表达式
100 #rsplit()
101 
102 #splitlines 按照换行符分割
103 print("a\nb\nc".splitlines(False))  # => 'a', 'b', 'c'
104 print("a\nb\nc".splitlines(True))   # =>  'a\n', 'b\n', 'c'
105 
106 #swapcase()  大小写转换

 1  li =[1,2,3,5,6,"zhou"]
 2  """修改"""
 3  li[0] = 'a'             #[a,2,3,5,6,"zhou"]
 4  li[1] = [11,22,33,44]   #['a', [11, 22, 33, 44], 3, 5, 6, 'zhou']
 5  li[4:6] = [66,77]       #['a', [11, 22, 33, 44], 3, 5, 66, 77]
 6 
 7  """删除"""
 8  del li[1]               #['a', 3, 5, 66, 77]
 9  del li[2:6]             #['a', 3]
10 
11 
12  """in""" 列表中的元素，以逗号作为分割 作为一个整体
13  'a' in li       #True
14 44 in ['a', [11, 22, 33, 44], 3, 5, 6, 'zhou']   False
15 
16  """"列表嵌套"""
17  li = ['a', [11, 22, 33, 44], 3, 5, 6, 'zhou']
18  # (li[1][1])      #第2个元素中的第二个元素
19 
20 """转换"""
21  s = "zhosdsadasd"
22  list_s = list(s)  #['z', 'h', 'o', 's', 'd', 's', 'a', 'd', 'a', 's', 'd']
23 
24  list_s= ['z', 'h', 'o', 's', 'd', 's', 'a', 'd', 'a', 's', 'd']
25  "".join(list_s)         #zhosdsadasd 只有字符串的情况下
26  s = s+str(item)         #既有数字又有字母
27 
28 """append""" #列表末尾追加 无返回值
29 li = [1,2,3,4]
30  v = li.append(5)
31  print(v)       #None
32  print(li)      #[1, 2, 3, 4, 5]
33 
34 """clear""" #清空
35  li.clear()
36  print(li)        #[]
37 
38 
39 """copy""" #拷贝,浅拷贝
40  v = li.copy()
41  print(v)           #[1, 2, 3, 4]
42 
43 """count""" #计算元素出现的次数
44  v = li.count(2)
45  print(v)             #1
46 
47 """extend"""  #与append不同，扩展原来的列表，参数是可迭代对象
48  li.extend([5,6])
49  print(li)        #[1, 2, 3, 4, 5, 6]
50  li.append([7,8])
51  print(li)        #[1, 2, 3, 4, 5, 6, [7, 8]]
52 
53 """index""" #根据值获取当前索引位置，只会找一处，可以加参数设定范围
54  li.index(3)
55 
56 """insert"""  #指定索引位置插入元素
57 
58  li.insert(0,99)
59  print(li)     #[99, 1, 2, 3, 4]
60 
61 """pop""" #删除并获取删除的值，可以加上索引，删除某个索引的值
62  li.pop()
63  print(li)        #[1, 2, 3]
64  li.pop(1)
65  print(li)       #[1, 3]
66  v = li.pop()    #4
67  v = li.pop(1)   #2
68 
69 
70 
71 """remove""" #删除列表中的第一次出现的指定值
72  li.remove(2)
73  print(li)      #[1, 3, 4]
74 
75 """reverse"""   #反转
76  li.reverse()
77  print(li)         #[4, 3, 2, 1]
78 
79  """sort"""    #排序
80  li.sort()
81  print(li)                  #[1, 2, 3, 4]
82  li.sort(reverse=True)
83  print(li)                 #[4, 3, 2, 1] 从大到小

 1 tu = (1,2,3,4,)
 2 #索引
 3 print(tu[0])         # 1
 4 
 5 #切片
 6 print(tu[1:3])       # (2, 3)
 7 
 8 #可以迭代 list.extend(tuple)
 9 for item in tu:
10     print(item)
11 
12 转换
13 s = "zhou"
14 tuple_s = tuple(s)
15 print(tuple_s)          #('z', 'h', 'o', 'u')
16 list_s = list(tuple_s)
17 print(list_s)           #['z', 'h', 'o', 'u']
18 
19 一级元素不可修改
20 
21 tuple_a = (1,[(2,3)],4)
22 tuple_a[1][0] = 567
23 print(tuple_a)     #(1, [567], 4)
24 
25 
26 count 统计某个元素出现的次数
27 
28 index 统计某个元素第一次出现的索引

 1 info = {
 2 "k1" : 18,
 3 "k2" : True,
 4 "k3" : [
 5     11,
 6     22,
 7     33,
 8   ]
 9 }
10 
11 print(info)
12 
13 
14 print(info['k1'])         #18
15 print(info['k2'])         #True
16 print(info['k3'])         #[11, 22, 33]
17 
18 
19 默认循环key
20 for k in info:
21     print(k)      #k1,k2,k3
22 
23 
24 key value 需要使用 dict.items()
25 for k,v in info.items():
26     print(k,v)
27 
28 删除
29 del info['k1']
30 
31 
32 
33 clear 同列表
34 copy  同列表元组
35 
36 fromkeys 按照序列生成字典，第二个参数为统一的值
37 v = dict.fromkeys(["k1","123","999"])
38 print(v)         #{'k1': None, '123': None, '999': None}
39 v = dict.fromkeys(["k1","123","999"],'111')
40 print(v)         #{'k1': '111', '123': '111', '999': '111'}
41 
42 get   跟dict[keys] 不同，找不到key会返还默认的None或者第二个参数
43 dict1 = {'key1':'value1'，'key2':'value2'}
44 v = dict1.get("key1")
45 print(v)                   #value1
46 v = dict1.get("key2")
47 print(v)                   #None
48 v = dict1.get("key2",111)
49 print(v)                   #111 第二个指定的参数
50 
51 pop 按照键值删除，得到值 当key不存在的时候 可以返回第二个参数 默认值
52 dict1 = {'key1': 'value1', 'key2': 'value2'}
53 v = dict1.pop('key1')
54 print(v)         #value1
55 v = dict1.pop('key3', 999)
56 print(v)           #999
57 
58 popitem 随机删除,并返回一个键值对
59 dict1 = {'key1': 'value1', 'key2': 'value2'}
60 v = dict1.popitem()
61 print(v)           #('key2', 'value2')
62 k, v = dict1.popitem()
63 print(k, v)          #key2 value2
64 
65 setdefault 设置一个值如果已经存在获取当前key对应的值，如果不存在会添加一个并获取其值
66 dict1 = {'key1': 'value1', 'key2': 'value2'}
67 v= dict1.setdefault('key1',111)
68 print(dict1)           #{'key1': 'value1', 'key2': 'value2'}
69 print(v)               #value1
70 v= dict1.setdefault('key3',111)
71 print(dict1)           #{'key1': 'value1', 'key2': 'value2', 'key3': 111}
72 print(v)               #111
73 
74 
75 update  更新，如果不存在添加一组
76 dict1 = {'key1': 'value1', 'key2': 'value2'}
77 dict1.update({'key1': 222, 'key3': 333})
78 print(dict1)      #{'key1': 222, 'key2': 'value2', 'key3': 333}
79 或者用关键字参数的方式
80 dict1.update(key1=222, key3=333)
81 print(dict1)        #{'key1': 222, 'key2': 'value2', 'key3': 333}
82 
83 keys()
84 values()
85 items()