1.数字整形
python3不管数字有多大都是int型，没有long类型
1>字符串转换为数字
s1 = "123" print(type(s1)，s1) b = int(s1)#不加base默认转换为十进制 print(type(b),b) b += 1000
输出：
<class 'str'> 123
<class 'int'> 123
s1 = "0011" s2 = "a" print(type(s1),s1) b = int(s1,base=2)#二进制 c = int(s2,base=16)#十六进制 print(type(b),b) print(type(c),c)
输出：
<class 'str'> 0011
<class 'int'> 3
<class 'int'> 10
2>-bit_length()方法
age = 7 # 7 111 # 3 11 # 1 01 # 当前数字的二进制至少用n位表示 r = age.bit_length() print(r)# 3
2.字符串
str
#!/usr/bin/env python # -*- coding:utf-8 -*- test = 'helLo' v = test.capitalize() # 首字母大写 print(v) # Hello v1 = test.casefold() # 所有变小写，更牛逼 print(v1) # hello v2 = test.lower() # 所有变小写 print(v2) # hello # 设置宽度，并将内容居中 # 20 代指总长度 # * 空白未知填充，一个字符，可有可无 v3 = test.center(20,'*') print(v3) # *******helLo******** # 去字符串中寻找子序列出现的次数 v4 = test.count('l',4) print(v4) # 0 # 以什么什么结尾或开始,返回bool v5 = test.endswith('lo') v6 = test.startswith('h') print(v5) print(v6) # 从开始往后找，找到第一个之后，获取其位置 test1 = 'hellohello' v7 = test1.find('oh', 4, 6) # 大于等于4，小于6 print(v7) # 4 # 格式化，将字符串中的占位符替换为指定的值 test2 = 'i am {name}, age {a}' print(test2) # 'i am {name}, age {a}' v8 = test2.format(name='Alex',a=18) print(v8) # i am Alex, age 18 test3 = 'i am {0}, age {1}' print(test3) # 'i am {0}, age {1}' v9 = test3.format('Alex',18) print(v9) # i am Alex, age 18 v10 = test2.format_map({"name":'Alex',"a":18}) print(v10) # i am Alex, age 18 v11 = test3.index("am") print(v11) # 判断字符串是否只包含数字和字母 v12 = test2.isalnum() print(v12) # False
s = "username\temail\tpassword\nAliex\taliex@q.com\t123456" s1 = s.expandtabs(20);# 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 print(s1)
输出：
username email password
Aliex aliex@q.com 123456
s2 = '②' s4 = s2.isdigit() # true s5 = s2.isdecimal()#flase print(s4,s5)
isprintable
是否存在不可显示的字符，\t = 制表符
s8 = 'fjdhf\tdhfds' s9 = s8.isprintable() print(s9)
True
以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
test = 'HELLO' t = '_' v = t.join(test) print(v)
输出：H_E_L_L_O
ljust，rjust
test = 'alex' v = test.ljust(20,'*') print(v) # alex**************** v2 = test.rjust(20,'#') print(v2) # ###############alex
截掉字符串的空格或指定字符（\t，\n也可以）。
test = ' alex ' v1 = test.lstrip() # 去掉左边的 v2 = test.rstrip() # 去掉右边的 v3 = test.strip() # 去掉左右两边的 print(v1,v2,v3) # alex alex alex
创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
test = 'aeiou' test1 = '12345' m = str.maketrans(test,test1) v = 'ahuwfeofjivuoiewsjnaeiou' new_v = v.translate(m) print(new_v)
输出：1h5wf24fj3v5432wsjn12345
test = 'testtysusnhfhjsl' v1 = test.partition('s') v2 = test.rpartition('s') print(v1,v2)
输出：
('te', 's', 'ttysusnhfhjsl') ('testtysusnhfhj', 's', 'l')
test = 'testtysusnhfhjsl'
v3 = test.split('s',2) print(v3)
输出：['te', 'tty', 'usnhfhjsl']
字符串一旦创建，不可修改
一旦修改或者拼接，都会造成重新生成字符串
range
# 帮助创建连续的数字 v = range(100) # 0, 1, 2, 3... v1 = range(0, 100) # 0, 1, 2, 3... v2 = range(0, 100, 5) # 0, 5, 10, 15... for item in v: print(item) for item in v1: print(item) for item in v2: print(item)
test = input('>>>') for item in range(len(test)): print(item,test[item])
3.列表
list # 类
li = [1, 12, 9, "age", "alex"]
中括号括起来，“，”分割每个元素，列表中的元素可以是数字，字符串...
集合内部可以放置任何东西
# 索引取值
print(li[3])
# 切片
print(li[1:3])
#!/usr/bin/env python # -*- coding:utf-8 -*- li = ['hello', 'world', 'python', 'linux', ['other', 'thing'], 'haha'] # 列表可以修改，内部是以链表形式实现 li[0] = [11, 22, 33] # 修改 li[2:4] = ['PYTHON', 'LINUX'] # 一次修改多个 del li[1] # 删除 del li[3:5] for item in li: print(item) print(li)
输出：
[11, 22, 33]
PYTHON
LINUX
[[11, 22, 33], 'PYTHON', 'LINUX']
#!/usr/bin/env python # -*- coding:utf-8 -*- li = ['hello', 'world', 'python', 'linux', ['other', 'thing'], 'haha'] # 列表可以修改，内部是以链表形式实现 li[0] = ['11', '22', '33'] # 修改 li[2:4] = ['PYTHON', 'LINUX'] # 一次修改多个 del li[1] # 删除 del li[3:5] for item in li: print(item) print(li) # 操作 print(li[0][1]) # 字符串转换列表 s = 'shffhfjdfe' l = list(s) print(l) # 列表转字符串 # 需要自己写for循环实现：既有数字又有字符串 new_s = '' for i in li: new_s += str(i) print(new_s) # 直接使用join方法：只有字符串 lii = ['hello', 'abcd', 'hsgdh'] v = ''.join(lii) print(v) # append 方法 # 在原来值后面追加 lii.append('hhhhh') print(lii) # ['hello', 'abcd', 'hsgdh', 'hhhhh'] # clear 方法 清空列表 lii.clear() print(lii) # 拷贝 liii = ['hello', 'abcd', 'hsgdh', 'hello'] v = liii.copy() # 浅拷贝 print(v) # count 方法 计算元素出现的次数 c = liii.count('hello') print(c) # extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。 # 参数是可迭代对象 liii.extend(['abcd', 'efgh']) # ['hello', 'abcd', 'hsgdh', 'hello', 'abcd', 'efgh'] liii.append(['abcd', 'efgh']) # ['hello', 'abcd', 'hsgdh', 'hello', 'abcd', 'efgh', ['abcd', 'efgh']] liii.extend('bbb') # ['hello', 'abcd', 'hsgdh', 'hello', 'abcd', 'efgh', ['abcd', 'efgh'], 'b', 'b', 'b'] print(liii) # insert() 在指定索引位置插入元素 li2 = [11, 22, 33, 44] li2.insert(0, 99) print(li2) # pop() 删除某个值（可以指定索引，默认删除最后一个），并获取删除的值 v = li2.pop(1) print(li2) print(v) # remove（） 删除列表中的指定值 li2.remove(33) print(li2) # reverse() 将当前列表进行反转 li2.reverse() print(li2) # sort() 排序 li2.sort() # 从小到大 li2.sort(reverse=True) # 从大到小 print(li2)
4.元祖
tuple
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
#!/usr/bin/env python # -*- coding:utf-8 -*- # tuple 元组,一级不可修改，增加或删除 # 一般写元组的时候，推荐在最后加入一个“，” test = ('hello', 'world',) print(test) # 可以被for 循环，可迭代对象 for i in test: print(i) # 字符串，列表，元组 可以相互转换 li = list(test) print(li) v = '_'.join(test) print(v) # hello_world # 元组的一级元素不可修改，二级等元素可以修改 tu = (111, 'abc', [33, 44]) tu[2][1] = 99 # 二级元素是列表，可以修改 print(tu)
输出：
('hello', 'world')
hello
world
['hello', 'world']
hello_world
(111, 'abc', [33, 99])
5.字典
dict
# 字典是另一种可变容器模型，且可存储任意类型对象。 #字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 info = {"k1": "v1", # 键值对 "k2": "v2"} print(info) # 字典是无序的 # 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。 dict1 = {1: 'a', 2: 'b'} print(dict1[1]) #del dict1[1] print(dict1) for item in dict1.keys(): # 键 print(item) for item in dict1.values(): # 值 print(item) for item in dict1.items(): # 键值对 print(item) # 根据序列，创建字典，并指定统一的值 v = dict.fromkeys(['k1', 123, '999']) print(v) # {'999': None, 123: None, 'k1': None} v = dict.fromkeys(['k1', 123, '999'], 1200) print(v) # {'k1': 1200, 123: 1200, '999': 1200} # get() 根据key获取值，当key不存在时，默认为None或指定 v = info.get('k1', 111) print(v) # pop() 删除 v = info.pop('k1') print(v) # popitem() 随机删除 info = {"k1": "v1", # 键值对 "k2": "v2"} v = info.popitem() print(info, v) # setdefault() 设置值，若已存在，则不设置，获取当前key对应的值 # 若不存在，设置 v = info.setdefault('k3', 'v3') print(info, v) # {'k1': 'v1', 'k3': 'v3'} v3 # update info.update({'k1': 'v111', 'k2': 'v222'}) info.update(k4='v4') print(info)
输出：
{'k2': 'v2', 'k1': 'v1'}
a
{1: 'a', 2: 'b'}
1
2
a
b
(1, 'a')
(2, 'b')
{'999': None, 123: None, 'k1': None}
{'999': 1200, 123: 1200, 'k1': 1200}
v1
v1
{'k1': 'v1'} ('k2', 'v2')
{'k3': 'v3', 'k1': 'v1'} v3
{'k4': 'v4', 'k3': 'v3', 'k2': 'v222', 'k1': 'v111'}
6.布尔值
bool
可变不可变类型：
可变：列表，字典
不可变：字符串，数字，元组
访问顺序：
1.顺序访问：字符串，列表，元组
2.映射：字典
3.直接访问：数字
存放元素个数：
容器类型：列表，元组，字典
原子：数字，字符串
7.集合
集合（set）是一个无序的不重复元素序列。
1.不同元素组成
2.无序
3.集合中元素必须是不可变类型
s = set('hello') print(s) s = set(['ab', 'ab', 'sb']) print(s) # add a = {1, 2, 3} a.add('3') # {'3', 1, 2, 3} a.add(3) print(a) # 清空 a.clear() print(a) # set() # pop随机删除 a = {1, 2, 3, 's'} a.pop() # {1, 2, 's'} print(a) #remove 可以指定删除元素,若删除元素不存在则报错 a = {1, 2, 3, 's'} a.remove(2) # {'s', 1, 3} #a.remove(5) error print(a) # discard 可以指定删除元素，若删除元素不存在不报错 a = {1, 2, 3, 's'} a.discard(2) # {1, 3, 's'} a.discard('cd') print(a) # 若无集合，求下面列表的交集 python_1 = ['a', 'b', 'c'] linux_1 = ['a', 'b', 'd'] python_and_linux = [] for i in python_1: if i in linux_1: python_and_linux.append(i) print(python_and_linux) # ['a', 'b'] # 集合关系测试 python_2 = ['a', 'b', 'c'] linux_2 = ['a', 'b', 'd'] python_s = set(python_2) linux_s = set(linux_2) # 并集 python_and_linux_s = python_s | linux_s print(python_and_linux_s) # {'d', 'c', 'a', 'b'} print(python_s.union(linux_s)) # {'b', 'a', 'c', 'd'} # 交叉补集 python_and_linux_s = python_s ^ linux_s print(python_and_linux_s) # {'c', 'd'} print(python_s.symmetric_difference(linux_s)) # {'c', 'd'} # 差集 print(python_s.difference(linux_s)) # {'c'} print(python_s - linux_s) # {'c'} print(linux_s - python_s) # {'d'} # 交集 python_and_linux_s = python_s & linux_s print(python_and_linux_s) # {'a', 'b'} python_and_linux_s = python_s.intersection(linux_s) print(python_and_linux_s) # {'a', 'b'} python_s.difference_update(linux_s) print(python_s) # {'c'} # isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 x = {"apple", "banana", "cherry"} y = {"google", "runoob", "facebook"} z = x.isdisjoint(y) print(z) # True #issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。 x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"} z = x.issubset(y) print(z) # True # update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略 x = {"apple", "banana", "cherry"} y = {"google", "runoob", "apple"} x.update(y) print(x) # {'banana', 'cherry', 'google', 'apple', 'runoob'} # 不可变集合 s = frozenset('hello') print(s)
扫一扫
2334
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
