本文详细介绍了Python中的基本数据类型，包括数字、布尔值、序列（字符串、列表、元组）、字典、集合等，涵盖了每种数据类型的常用操作、方法及注意事项。
1.数字类型
数字是不可更改类型，直接访问。主要用于计算、运算。
1.1常见方法。
bit_length
''' | bit_length(...) | int.bit_length() -> int | | Number of bits necessary to represent self in binary. '输出该数字的二进制表示方式所占的位数' ''' # 例 for i in range(5): print('数字%d占二进制位数为%d' % (i, i.bit_length())) ''' 结果 数字0占二进制位数为0 数字1占二进制位数为1 数字2占二进制位数为2 数字3占二进制位数为2 数字4占二进制位数为3 二进制 十进制 0000 0000 0 0000 0001 1 0000 0010 2 0000 0011 3 0000 0100 4 '''
1.2 python进制的转化
# binary 二进制 # octal 八进制 # hex 十六进制 a = 10 print(bin(a)) # 0b1010 # 十进制的数转换成二进制的数，0o开头就是二进制的数字 # 0 1 10 11 print(oct(a)) # 0o12 # 十进制的数转换成八进制的数，0o开头就是八进制的数字 # 1 2 3 4 5 6 7 print(hex(a)) # 0xa # 十进制的数转换成十六进制的数，0o开头就是十六进制的数字 # 0 1 2 3 4 5 6 7 8 9 a b c d e f print(int('10010', base=2)) # 18 print(int('10010', base=10)) # 10010 print(int('10010', base=8)) # 4104 print(int('10010', base=16)) # 65552
2.布尔值bool
布尔值就两种：True，False。就是反应条件的正确与否。
''' 下列对象的布尔值是False None False（布尔类型） 所有的值为零的数 0（整型） 0.0+0.0（复数) ''（空字符串） []（空列表） {}（空字典） ()（空元组） '''
3.序列sequence
3.1序列介绍
在python中，序列有着相同访问模式：它的每一个元素可以通过指定一个下标的方式获得。而多个元素可以通过切片操作的方式一次得到，下标是从0开始到总元素数（序列的长度）-1结束。常见的序列有字符串、列表、元组。
3.2序列操作符
seq = 'What is you name?' # 成员操作符（in、not in） print('w' in seq) # False print('w' not in seq) # True # 链接操作符（+） seq = seq + ' python' print(seq) # What is you name? python # 重复操作符（*） seq = seq * 2 print(seq) # What is you name? pythonWhat is you name? python
3.3序列索引与切片
索引
# 根据下标打印相应内容 s = 'python自动化运维21期' for i in range(len(s)): print(i, s[i]) # 0 p # 1 y # 2 t # 3 h # ... # 12 1 # 13 期
切片
# 序列的切片，下标（索引）范围为0...序列长度-1，遵循顾头不顾尾的原则，如果开始为0或结束为序列长度-1，可以不写 # s[起始索引:结束索引+1:步长] # 正向打印字符串 print(s[:]) # python自动化运维21期 print(s[6:9]) # 自动化 # 可以按步长取值，步长必须保持一致，不能变化 print(s[0:9:2]) # pto自化 # 反向打印字符串 print(s[::-1]) # 期12维运化动自nohtyp
4.字符串类型
可以通过在引号间包含字符的方式创建，可存储少量数据，是不可更改类型。python中的单引号和双引号作用是相同的。
# 1.capitalize与titile ''' capitalize 1)翻译 英 [ˈkæpɪtəlaɪz] 美 [ˈkæpɪtl:ˌaɪz] vt.用大写字母写或印刷;使…资本化;估计…的价值;把…定为首都 vi.利用;积累资本 2)源码注释 | capitalize(...) | S.capitalize() -> str | | Return a capitalized version of S, i.e. make the first character | have upper case and the rest lower case. 3)作用 字符串首字母大写，其余全部小写 ''' # 例 s = 'lemon TREE' s1 = s.capitalize() print(s1) # Lemon tree ''' title 1)翻译 title 英 [ˈtaɪtl] 美 [ˈtaɪtl] n.标题;头衔;[体]冠军;[影视]字幕 vt.加标题;赋予头衔;把…称为 adj.标题的;冠军的;头衔的 2)源码注释 | title(...) | S.title() -> str | | Return a titlecased version of S, i.e. words start with title case | characters, all remaining cased characters have lower case. 3)作用 字符串中每个单词的首字母大写，其余字母都小写 ''' # 例 s = 'lemon TREE' s2 = s.title() print(s2) # Lemon Tree # 2.upper与lower # *** upper(), lower() 全部大写，全部小写，在编写输入验证码时比较常见 ''' 1)翻译 upper 英 [ˈʌpə(r)] 美 [ˈʌpɚ] adj.上面的;地位较高的;内地的;地表层的 n.鞋帮，靴面;兴奋剂;令人兴奋的经历 2)源码解释 | upper(...) | S.upper() -> str | | Return a copy of S converted to uppercase. 3)作用 字符串字母全部大写 ''' # 例 s = 'lemon TREE' s3 = s.upper() print(s3) # LEMON TREE ''' 1)翻译 lower 英 [ˈləʊə(r)] 美 [ˈloʊə(r)] adj.下方的;在底部的;较低级的 v.降低;减少;缩小 2)源码解释 | lower(...) | S.lower() -> str | | Return a copy of the string S converted to lowercase. 3)作用 字符串字母全部小写 ''' s = 'lemon TREE' s5 = s.lower() print(s5) # lemon tree # 3.* 大小写反转 swapcase() ''' 1)翻译 swap 英 [swɒp] 美 [swɑp] n.交换;交换物，被掉换者 vi.交换（工作） vt.用…替换，把…换成，掉换（过来） case 英 [keɪs] 美 [kes] n.（实）例，事例;情况，状况;诉讼（事件），案件，判例;容器（箱，盒） vt.把…装入箱（或盒等）内;加盖于;包围，围住;[俚语]（尤指盗窃前）探察，侦查，窥测 2)源码解释 | swapcase(...) | S.swapcase() -> str | | Return a copy of S with uppercase characters converted to lowercase | and vice versa. 3)作用 将字符串的大小写翻转 ''' # 例 s = 'lemon TREE' s6 = s.swapcase() print(s6) # LEMON tree # 4.居中center()，左对齐ljust()，右对齐rjust()， zfill() ''' 1)翻译 center 英 ['sentə] 美 [ˈsɛntɚ] n.中心;中枢;（球队的） 中锋;中心区 adj.中央的，位于正中的;（在）中心的 vt.集中;使聚集在一点;定中心;居中 vi.居中，有中心，被置于中心 2)源码解释 | center(...) | S.center(width[, fillchar]) -> str | | Return S centered in a string of length width. Padding is | done using the specified fill character (default is a space) 相关单词：fillchar == fill character fill 英 [fɪl] 美 [fɪl] vt.& vi.（使）充满，（使）装满 vt.满足;配药;（按订单）供应;使充满（感情） n.填满…的量;充分;装填物;路堤 character 英 [ˈkærəktə(r)] 美 [ˈkærəktɚ] n.性格;角色;特点;字母 vt.刻，印;使具有特征 3)作用 居中，长度自己设定，默认填充物是None,space，填充物必须是单个字符，不可以是int、bool等 ''' # 例 s = 'lemon TREE' s7 = s.center(30) print(s7) # lemon TREE s8 = s.center(30, '-') print(s8) # ----------lemon TREE---------- ''' ljust == left-justified 1)翻译 英 ['leftdʒ'ʌstɪfaɪd] 美 ['leftdʒ'ʌstɪfaɪd] v.左对齐( left-justify的过去式和过去分词 ) 2)源码解释 | ljust(...) | S.ljust(width[, fillchar]) -> str | | Return S left-justified in a Unicode string of length width. Padding is | done using the specified fill character (default is a space). 3)作用 左对齐，长度自己设定必须添加，否则会报错，默认填充物是space，填充物必须是单个字符，不可以是int、bool等 TypeError: ljust() takes at least 1 argument (0 given) ''' # 例 s = 'lemon TREE' s9 = s.ljust(20) print(s9) # lemon TREE s10 = s.ljust(20, '-') print(s10) # lemon TREE---------- ''' rjust == right-justified 1)翻译 英 ['raɪtdʒ'ʌstɪfaɪd] 美 ['raɪtdʒ'ʌstɪfaɪd] [计] 右对齐的 2)源码解释 | rjust(...) | S.rjust(width[, fillchar]) -> str | | Return S right-justified in a string of length width. Padding is | done using the specified fill character (default is a space). 3)作用 右对齐，长度自己设定，默认填充物是None,space，填充物必须是单个字符，不可以是int、bool等 ''' # 例 s = 'lemon TREE' s11 = s.rjust(20) print(s11) # lemon TREE s12 = s.rjust(20, '-') print(s12) # ----------lemon TREE ''' zfill 1)翻译 zfill == zero fill 2)源码解释 | zfill(...) | S.zfill(width) -> str | | Pad a numeric string S with zeros on the left, to fill a field | of the specified width. The string S is never truncated. 3)作用 zfill方法返回指定长度的字符串，原字符串右对齐，前面填充0。 ''' #例 s = 'lemon TREE' s13 = s.zfill(20) print(s13) # 0000000000lemon TREE # 5.以...开始startswith()、以...结束endswith() ''' startswith 1)翻译 以...开始 2)源码解释 | startswith(...) | S.startswith(prefix[, start[, end]]) -> bool | | Return True if S starts with the specified prefix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | prefix can also be a tuple of strings to try. 3)作用 检查字符串是否是以相应字符串开头，是则返回 True，否则返回 False。如果开始和结束指定值，则在指定范围内检查。 ''' # 例 s = 'lemon TREE' print(s.startswith('a')) # False print(s.startswith('lemon')) # True print(s.startswith('lemon TREE')) # True print(s.startswith('lemon TREE', 0,-1)) # False print(s.startswith('lemon TREE', 0,)) # True ''' endswith 1)翻译 以...结束 2)源码解释 | endswith(...) | S.endswith(suffix[, start[, end]]) -> bool | | Return True if S ends with the specified suffix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | suffix can also be a tuple of strings to try. 3)作用 检查字符串是否是以相应字符串结束，是则返回 True，否则返回 False。如果开始和结束指定值，则在指定范围内检查。 ''' # 例 s = 'lemon TREE' print(s.endswith('E')) # True print(s.endswith('e')) # False print(s.endswith('lemon TREE')) # True print(s.endswith('lemon TREE', 0, -1)) # False print(s.endswith('lemon TREE', 0)) # True # 6.去除空格，制表符，换行符strip()/lstrip()/rstrip() ''' strip 1)翻译 英 [strɪp] 美 [strɪp] vi.剥光;剥除 vt.除去，剥去;剥夺;删除;清除，拆除 n.长条，条板;带状地带（或森林、湖面等）;（足球队员的）运动服 2)源码解释 | strip(...) | S.strip([chars]) -> string or unicode | | Return a copy of the string S with leading and trailing | whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping 3)作用 去除首尾的空格，制表符\t，换行符，项目中必须添加。可以填加填充物，多个字符表示迭代着去，前后去t->e->y lstrip()/rstrip()用法类似 ''' # 例 s = ' \tlemon tree\n' s14 = s.strip() print(s14) # lemon tree # 迭代着去除，先去除'-'，再去除'+'，再去除'*' s = '--++**lemon tree**++--' s15 = s.strip('-+*') print(s15) # lemon tree # 7.分割字符串split()/rsplit() ''' split 1)翻译 英 [splɪt] 美 [splɪt] vt.分裂;分开;<俚>（迅速）离开;分担 n.划分;分歧;裂缝;劈叉 vi.<俚>走开;揭发;被撞碎;<美>[证券]（股票）增加发行 adj.裂开的，劈开的，分离的，分裂的 2)源码解释 | split(...) | S.split([sep [,maxsplit]]) -> list of strings | | Return a list of the words in the string S, using sep as the | delimiter string. If maxsplit is given, at most maxsplit | splits are done. If sep is not specified or is None, any | whitespace string is a separator and empty strings are removed | from the result. 3)作用 以seq为分隔符截取字符串，默认按照空格分割，可以添加分割字符的个数，如果是2，则返回的列表有三个元素 ''' # 例 s = 'lemon TREE' s16 = s.split() print(s16) # ['lemon', 'TREE'] s = 'lemonTREE' s17 = s.split() print(s17) # ['lemonTREE'] # 如果分割符在开始，返回列表则添加''元素 s = 'oldboyowusiroalex' s18 = s.split('o') print(s18) # ['', 'ldb', 'y', 'wusir', 'alex'] # 添加分割字符的个数，如果是2，则返回的列表有三个元素 s19 = s.split('o', 2) print(s19) # ['', 'ldb', 'yowusiroalex'] # rstrip()从右向左分割 ''' rstrip 1)翻译 right split 2)源码解释 | rsplit(...) | S.rsplit(sep=None, maxsplit=-1) -> list of strings | | Return a list of the words in S, using sep as the | delimiter string, starting at the end of the string and | working to the front. If maxsplit is given, at most maxsplit | splits are done. If sep is not specified, any whitespace string | is a separator. 3)作用 用法和split相同，只不过是从右向左分割 ''' # 例 s = 'oldboyowusiroalex' s20 = s.rsplit('o', 2) print(s20) # ['oldboy', 'wusir', 'alex'] # 8.连接字符串join() ''' join 1)翻译 英 [dʒɔɪn] 美 [dʒɔɪn] vt.& vi.加入;参加;连接;联结 vt.参与;结合;上（火车、飞机等）;上（路） n.连接;结合;接合处;接合点 2)源码解释 | join(...) | S.join(iterable) -> str | | Return a string which is the concatenation of the strings in the | iterable. The separator between elements is S. 3)作用 以指定字符串作为分隔符，将字符串中所有的元素(的字符串表示)合并为一个新的字符串，也可以在列表中使用 ''' # 例 s = 'lemon TREE' s21 = '-*-'.join(s) print(s21) # l-*-e-*-m-*-o-*-n-*- -*-T-*-R-*-E-*-E l = ['lemon', 'tree'] s22 = '-*-'.join(l) print(s22) # lemon-*-tree # 9.替换replace() ''' replace 1)翻译 英 [rɪˈpleɪs] 美 [rɪˈples] vt.代替;替换;把…放回原位;（用…）替换 2)源码解释 | replace(...) | S.replace(old, new[, count]) -> str | | Return a copy of S with all occurrences of substring | old replaced by new. If the optional argument count is | given, only the first count occurrences are replaced. 3)作用 (老的，新的，次数(什么都不写为全部替换)) 将字符串中的str1替换成str2，如果count指定，则替换不超过count次。 ''' # 例 s = 'lemon tree' s23 = s.replace('e', 'E') print(s23) # lEmon trEE # 只把'e'替换成'E'两次 s24 = s.replace('e', 'E', 2) print(s24) # lEmon trEe # 10.搜索find()/index() ''' find 1)翻译 英 [faɪnd] 美 [faɪnd] v.找到;发现;查明;发觉 n.发现物;被发现的人 2)源码解释 | find(...) | S.find(sub[, start[, end]]) -> int | | Return the lowest index in S where substring sub is found, | such that sub is contained within S[start:end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. 3)作用 检测sub是否包含在字符串中，如果指定范围start和end，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 ''' # 例 s = 'lemon tree' print(s.find('e')) # 1 print(s.find('E')) # -1 # 如果是多个字符的字符串，输入匹配到的字符的第一个字符的下标 print(s.find('tree')) # 6 print(s.find('lemon', 0)) # 0 print(s.find('tree', 0, 6)) # -1 ''' index 1)翻译 英 [ˈɪndeks] 美 [ˈɪnˌdɛks] n.索引;<数>指数;指示;标志 vt.给…编索引;把…编入索引;[经济学]按生活指数调整（工资、价格等） vi.[机械学]转位 2)源码解释 | index(...) | S.index(sub[, start[, end]]) -> int | | Like S.find() but raise ValueError when the substring is not found. 3)作用 检测sub是否包含在字符串中，如果指定范围start和end，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则会报错 ''' # 例 s = 'lemon tree' print(s.index('e')) # 1 # ind = s.index('XX') # print(ind) # ind = s.index('XX') # ValueError: substring not found # 11.格式化输出format() ''' format 1)翻译 英 [ˈfɔ:mæt] 美 [ˈfɔ:rmæt] n.（出版物的）版式;[自]（数据安排的）形式;电视节目的总安排（或计划） vt.使格式化;安排…的格局;设计…的版面 vi.设计一个版式 2)源码解释 | format(...) | S.format(*args, **kwargs) -> str | | Return a formatted version of S, using substitutions from args and kwargs. | The substitutions are identified by braces ('{' and '}'). 3)作用 用于字符串的格式化 ''' # 例 # 通过站位符输出 s25 = '这是{}的{}个{}'.format('我', '第一', '博客') print(s25) # 这是我的第一个博客 # 通过位置输出，便于输出带有重复字符的字符串 s26 = '这是{0}的{1}个{2}，欢迎大家光临我的{2}'.format('我', '第一', '博客') print(s26) # 这是我的第一个博客，欢迎大家光临我的博客 # 通过关键字输出 s27 = '这是{who}的{num}个{what}'.format(who='我', num='第一', what='博客') print(s27) # 这是我的第一个博客 # 12.公共方法len()/count() ''' len == length 1)翻译 length 英 [leŋθ] 美 [leŋθ] n.长度，长;时间的长短;（语）音长;一段，一节 2)源码解释 len(obj, /) Return the number of items in a container. 3)作用 返回序列的长度 ''' # 例 s = 'lemon tree' print(len(s)) # 10 ''' count 1)翻译 英 [kaʊnt] 美 [kaʊnt] n.总数;数数;罪状;论点 v.数数;计算总数;把…算入;重要 2)源码解释 | count(...) | S.count(sub[, start[, end]]) -> int | | Return the number of non-overlapping occurrences of substring sub in | string S[start:end]. Optional arguments start and end are | interpreted as in slice notation. 3)作用 统计sub在字符串中出现的次数，可以添加范围 ''' s = 'lemon tree' s28 = s.count('e') print(s28) # 3 s29 = s.count('E') print(s29) # 0 # 13.is系列 ''' isalnum = is alphanumeric 1)翻译 英 [ˌælfənju:ˈmerɪk] 美 [ˌælfənu:ˈmerɪk] adj.文字数字的，包括文字与数字的 2)源码解释 | isalnum(...) | S.isalnum() -> bool | | Return True if all characters in S are alphanumeric | and there is at least one character in S, False otherwise. 3)作用 判断字符串是否仅由字母或数字且至少一个由数字或者字母组成 ''' # 例 s30 = '1' print(s30.isalnum()) # True s31 = 'a' print(s31.isalnum()) # True s32 = '1a' print(s32.isalnum()) # True s33 = '' print(s33.isalnum()) # False s34 = '+1' print(s34.isalnum()) # False ''' isalpha = is alphabetic 1)翻译 英 [ˌælfəˈbetɪk] adj.照字母次序的，字母的 2)源码解释 | isalpha(...) | S.isalpha() -> bool | | Return True if all characters in S are alphabetic | and there is at least one character in S, False otherwise. 3)作用 判断字符串是否仅由字母且至少一个字母组成 ''' # 例 s35 = 's+' print(s35.isalpha()) # False s36 = 's6' print(s36.isalpha()) # False s37 = 's' print(s37.isalpha()) # True ''' isdigit = is digit 1)翻译 英 [ˈdɪdʒɪt] 美 [ˈdɪdʒɪt] n.数字;手指，足趾;一指宽 2)源码解释 | isdigit(...) | S.isdigit() -> bool | | Return True if all characters in S are digits | and there is at least one character in S, False otherwise. 3)作用 判断字符串是否仅由字母且至少一个数字组成 ''' # 例 s38 = '5' print(s38.isdigit()) # True s39 = '5s' print(s39.isdigit()) # False s40 = '5+' print(s40.isdigit()) # False
5.列表list
容器型数据类型,可变数据类型。可以包含数字、布尔值、字符串、列表、元组、字典、集合等元素，例如：[True, 1, 'name', {'name': 'oldboy'}, [1, 2, 3], (2, 3, 4), set(1, 2, 3)]，可以进行检索和索引等操作
5.1增删改查
增：
# 1.在列表末尾添加新的对象append ''' append 1)翻译 英 [əˈpend] 美 [əˈpɛnd] vt.附加;添加;贴上;签（名） 2)源码注释 | append(...) | L.append(object) -> None -- append object to end 3)作用 在列表末尾添加新的对象 ''' # 例 l = [1, 2, 3, 4] l.append(5) print(l) # [1, 2, 3, 4, 5] # 这个是一个动作，没有返回值，所以是None print(l.append(6)) # None # 2.按照索引插入insert ''' insert 1)翻译 英 [ɪnˈsɜ:t] 美 [ɪnˈsɜ:rt] vt.插入;嵌入;（在文章中）添加;加插 n.插入物;添入物（尤指一页印刷品图中插入或套印的小图）;（书报的）插页;添加物 2)源码注释 | insert(...) | L.insert(index, object) -- insert object before index 3)作用 在索引的前面插入对象 ''' # 例 l = ['apple', 'banana', 'orange'] l.insert(1, 'pear') print(l) # ['apple', 'pear', 'banana', 'orange'] # 3.迭代着增加extend ''' extend 1)翻译 英 [ɪkˈstend] 美 [ɪkˈstɛnd] vt.& vi.延伸;扩大;推广 vt.延长;伸展;给予;发出（邀请、欢迎等） vi.延伸;伸出;增加 2)源码注释 | extend(...) | L.extend(iterable) -> None -- extend list by appending elements from the iterable 3)作用 迭代着增加，把序列分解成最小元素添加到原列表的结尾 ''' # 例 l1 = ['a', 'b', 'c'] l2 = ['d', 'e', 'f'] l1.extend(l2) print(l1) print(l2) # ['a', 'b', 'c', 'd', 'e', 'f'] # ['d', 'e', 'f'] l2.extend('567') print(l2) # ['d', 'e', 'f', '5', '6', '7'] '''
删：
# 1.有返回值的删除pop() ''' pop 1)说明 有返回值的删除 2)源码解释 | L.pop([index]) -> item -- remove and return item at index (default last). | Raises IndexError if list is empty or index is out of range. 3)作用 用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。 ''' # 例 # 不添加下标删除，默认列表最后一个元素 l = ['a', 'b', 'c', 'd'] l.pop() print(l) # ['a', 'b', 'c'] # 根据下标删除列表的元素 l = ['a', 'b', 'c', 'd'] l.pop(1) print(l) # ['a', 'c', 'd'] # 有返回值，可以看到删除的元素 l = ['a', 'b', 'c', 'd'] print(l.pop(1)) # b # 2.按照元素删除remove() ''' remove 1)翻译 英 [rɪˈmu:v] 美 [rɪˈmuv] vt.去除;开除;脱掉，拿下;迁移 vi.迁移，移居;离开 n.距离，差距;移动 2)源码解释 | L.remove(value) -> None -- remove first occurrence of value. | Raises ValueError if the value is not present. 3)作用 根据元素删除，如果不添加参数会报错 ''' # 例 l = ['a', 'b', 'c', 'd'] l.remove('d') print(l) # ['a', 'b', 'c'] # 3.清空列表clear() ''' clear 1)源码解释 L.clear() -> None -- remove all items from L 2)作用 清空列表，返回一个空列表 ''' # 例 l = ['a', 'b', 'c', 'd'] l.clear() print(l) # [] # 4.内存级别删除del ''' del -- delete 删除 内存级别删除 ''' l = ['a', 'b', 'c', 'd'] del l print(l) # NameError: name 'l' is not defined
改：
# 1.按照索引修改 l = ['a', 'b', 'c', 'd'] l[2] = 'e' print(l) # ['a', 'b', 'e', 'd'] # 2.按照切片修改 l = ['a', 'b', 'c', 'd'] l[1:3] = [1, 2] print(l) # ['a', 1, 2, 'd']
查：
# 1.按照索引查看列表元素 l = ['a', 'b', 'c', 'd'] print(l[0]) # a # 2.按照切片查看列表元素 l = ['a', 'b', 'c', 'd'] print(l[2:4]) # ['c', 'd'] print(l[::2]) # ['a', 'c'] # 3.循环查看列表 l = ['a', 'b', 'c', 'd'] for i in l: print(i) # a # b # c # d
5.2其他方法：
# 1.统计列表中元素个数count l = ['a', 'b', 'c', 'd', 'a'] print(l.count('a')) # 2 # 2.统计列表长度len l = ['a', 'b', 'c', 'd', 'a'] print(len(l)) # 5 # 3.查找元素下标index，输出列表中第一个出现该元素的下标 l = ['a', 'b', 'c', 'd', 'a'] ind = l.index('a') print(ind) # 0 ind = l.index('f') # ValueError: 'f' is not in list # 4.排序sort # 从大到小 l = ['c', 'd', 'a', 'b'] l.sort(reverse=True) print(l) # 从小到大 l = ['c', 'd', 'a', 'b'] l.sort(reverse=False) print(l) # ['a', 'b', 'c', 'd'] # 默认从小到大 l = ['c', 'd', 'a', 'b'] l.sort() print(l) # ['a', 'b', 'c', 'd'] # 5.反向输出列表 l = ['c', 'd', 'a', 'b'] l.reverse() print(l) # ['b', 'a', 'd', 'c'] # 6.列表的嵌套 l = [1, 2, 3, [4, 5, 6]] print(l[3][2]) # 6
6.字典dict
6.1介绍
字典典的key是唯一的。key 必须是不可变的数据类型。
key:不可变的数据类型(可哈希)：str，bool，tuple，int。
value：任意数据类型。
数据类型分类：
不可变的数据类型(可哈希)：str，bool，tuple，int
可变的数据类型：dict，list，set。
容器类数据类型：list，tuple，dict，set.
字典：存储数据多，关系型数据，查询速度快（二分查找）。
3.6版本之前，字典是无序的，3.6之后字典是有序的。
6.2常见方法
创建字典：
# 创建字典 # 1. 创建空字典 dic = {} print(dic , type(dic)) # {} <class 'dict'> # 2. 直接赋值创建字典 dic = {'a': 1, 'b': 2, 'c': 3} print(dic , type(dic)) # {'a': 1, 'b': 2, 'c': 3} <class 'dict'> # 3. 通过关键字dict和关键字参数创建字典 dic = dict(a=1, b=2, c=3) print(dic , type(dic)) # {'a': 1, 'b': 2, 'c': 3} <class 'dict'> # 4. 通过二元组列表创建字典 lst = [('a', 1), ('b', 2), ('c', 3)] dic = dict(lst) print(dic , type(dic)) # {'a': 1, 'b': 2, 'c': 3} <class 'dict'> # 5. dict和zip结合创建字典 # 5.1 - 通过两个字符串创建字典 dic = dict(zip('abc', '123')) print(dic , type(dic)) # {'a': '1', 'b': '2', 'c': '3'} <class 'dict'> # 5.2 - 通过一个字符串、一个列表创建字典 dic = dict(zip('abc', [1,2,3])) print(dic , type(dic)) # {'a': 1, 'b': 2, 'c': 3} <class 'dict'> # 5.3 - 通过一个字符串、一个元组创建字典 dic = dict(zip('abc', (1,2,3))) print(dic , type(dic)) # {'a': 1, 'b': 2, 'c': 3} <class 'dict'> # 5.4 - 通过两个列表串创建字典 lst1 = ['a', 'b', 'c'] lst2 = [1, 2, 3] dic = dict(zip(lst1, lst2)) print(dic , type(dic)) # {'a': 1, 'b': 2, 'c': 3} <class 'dict'> # 5.5 - 通过两个列表串创建字典延伸 lst = ['a', 1, 'b', 2, 'c', 3] dic = dict(zip(lst[::2], lst[1::2])) print(dic , type(dic)) # {'a': 1, 'b': 2, 'c': 3} <class 'dict'> # 6. 通过字典推导式创建字典 dic = {i:2*i for i in range(3)} print(dic , type(dic)) # {0: 0, 1: 2, 2: 4} <class 'dict'> # 7. 通过dict.fromkeys()创建字典 # 通常用来初始化字典，设置value的默认值 dic = dict.fromkeys(range(3), 'x') print(dic , type(dic)) # {0: 'x', 1: 'x', 2: 'x'} <class 'dict'>
增：
# 1.有则覆盖，无则添加 dic = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} dic['high'] = 180 print(dic) # {'name': 'xiaoming', 'age': 30, 'hobby': 'games', 'high': 180} dic['name'] = 'ritian' print(dic) # {'name': 'ritian', 'age': 30, 'hobby': 'games', 'high': 180} # 2.有则不变，无则添加setdefault() # 无则添加 dic = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} dic.setdefault('high', 190) print(dic) # {'name': 'xiaoming', 'age': 30, 'hobby': 'games', 'high': 190} dic.setdefault('name', '日天') print(dic) # {'name': 'xiaoming', 'age': 30, 'hobby': 'games', 'high': 190}
删：
# 1.根据键删除对应值，有返回值pop() dic = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} print(dic.pop('name')) # xiaoming print(dic) # {'age': 30, 'hobby': 'games'} # 2.清空字典clear() dic = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} dic.clear() print(dic) # {} # 3.删除字典随机值，有返回值popitem() dic = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} print(dic.popitem()) # ('hobby', 'games') print(dic) # {'name': 'xiaoming', 'age': 30}
改：
# 1.直接更改 dic = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} dic['name'] = '小明' print(dic) # {'name': '小明', 'hobby': 'games', 'age': 30} # 2.字典更新update() dic1 = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} dic2 = {'weight': 75, 'high': 180, 'age': 31} # 将dic2中的键值对覆盖添加到dic1中 dic1.update(dic2) print(dic1) # {'name': 'xiaoming', 'age': 31, 'weight': 75, 'high': 180, 'hobby': 'games'}
查：
# 1.根据键查 dic = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} print(dic['name']) # xiaoming # 2.根据值查get() print(dic.get('name')) # xiaoming # 可以添加描述性语句 print(dic.get('high', '没有此键')) # 没有此键 # 3.循环打印键keys()/值values()/键值对items() # 打印键key() for i in dic.keys(): print(i) # name # hobby # age # 值values() for j in dic.values(): print(j) # xiaoming # games # 30 # 键值对items() for k in dic.items(): print(k) # ('name', 'xiaoming') # ('age', 30) # ('hobby', 'games')
其他方法：
# 1.字典长度len dic = {'name': 'xiaoming', 'age': 30, 'hobby': 'games'} print(len(dic)) # 3 # 2.fromkeys # dict.fromkeys(seq[, value]) # fromkeys函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。 dic1 = dict.fromkeys('abc', 'name') print(dic1) # {'c': 'name', 'b': 'name', 'a': 'name'} dic2 = dict.fromkeys([1,2,3], 'id') print(dic2) # {1: 'id', 2: 'id', 3: 'id'} # 使用字典更改值的方法，其他键值对不会更改 dic2[1] = '序号' print(dic2) # 使用列表的追加方法，所有键的值都会更改 dic3 = dict.fromkeys('abc', []) print(dic3) # {'a': [], 'c': [], 'b': []} dic3['a'].append('apple') print(dic3) # {'b': ['apple'], 'c': ['apple'], 'a': ['apple']} # 3.字典的嵌套与列表的嵌套方式类似
7.元组tuple
元组是容器型数据类型,不可变数据类型，单元组的子元素的元素可以更改。
tu = (11, 2, True, [2,3,4], 'string') # 1.循环打印 for i in tu: print(i) # 11 # 2 # True # [2, 3, 4] # string # 2.索引打印 print(tu[1]) # 2 # 3.切片打印，打印结果还是元组 print(tu[:3:2]) # (11, True) # 4.查看元素下标 print(tu.index(True)) # 2 # 5.统计元素个数 print(tu.count(2)) # 1 # 6.统计元组长度 print(len(tu)) # 5 # 7.更改子元素的元素 tu[-2].append(666) print(tu) # (11, 2, True, [2, 3, 4, 666], 'string')
8.集合set
集合：无序，不重复的数据类型。它里面的元素必须是可哈希的，但是集合本身是不可哈希的。
python可哈希数据类型：数字、布尔值、字符串、元组
不可哈希数据类型：列表、字典
8.1定义集合
# 定义：数字、字符串、布尔值、元组 set1 = {1, 'string', False, (4, 5, 6)} print(set1) # {False, 1, (4, 5, 6), 'string'}
8.2可以用于列表的去重
# 列表去重 l1 = [1, 1, 2, 2, 3, 4, 5, 6] l2 = list(set(l1)) print(l2) # [1, 2, 3, 4, 5, 6]
8.3增、删
增
# 1.增add() set2 = {1, 'string', False, (4, 5, 6)} set2.add(666) print(set2) # {False, 1, 666, (4, 5, 6), 'string'} # 2.更新update()，将对象分割成最小元素添加到集合中 set2.update('abc') print(set2) # {False, 1, 'string', 'a', 'c', 'b', 666, (4, 5, 6)}
删
# 1.删除指定元素remove() set1 = {1, 'string', False, (4, 5, 6)} set1.remove(1) print(set1) # {False, 'string', (4, 5, 6)} # 2.随机删除一个元素pop() set1 = {1, 'string', False, (4, 5, 6)} set1.pop() print(set1) # {1, 'string', (4, 5, 6)} # 3.清空集合clear() set1 = {1, 'string', False, (4, 5, 6)} set1.clear() print(set1) # set() # 4.内存级删除集合del set1 = {1, 'string', False, (4, 5, 6)} del set1 print(set1)
# NameError: name 'set1' is not defined
8.4关系测试：交集、并集、差集、子集...
set1 = {1, 2, 3, 4, 5, 6}
set2 = {5, 6, 7, 8, 9, 10}
# 1.交集 & intersection
# set1和set2共有的
print(set1 & set2)
# {5, 6}
print(set1.intersection(set2))
# {5, 6}
# 2.并集 | union
# set1+set2独有的
print(set1 | set2)
# {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
print(set1.union(set2))
# {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
# 3.差集 - difference
# set1有而set2没有
print(set1 - set2)
# {1, 2, 3, 4}
# 4.反交集 ^ symmetric_difference
# set1中set2没有的+set2中set1没有的
print(set1 ^ set2)
# {1, 2, 3, 4, 7, 8, 9, 10}
print(set1.symmetric_difference(set2))
# {1, 2, 3, 4, 7, 8, 9, 10}
# 5.子集
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
# 判断set1是不是set2的子集
print(set1 < set2)
# True
print(set1.issubset(set2))
# True
# 6.超集
# 判断set2是不是set1的超集
print(set2 > set1)
# True
print(set2.issuperset(set1))
# True
# 7.不可变集合，冻集frozenset()
set1 = frozenset('apple')
print(set1)
# frozenset({'p', 'a', 'l', 'e'})
print(type(set1))
# <class 'frozenset'>
9.数据类型的补充
# 1.按步长删除列表的值 # 最直接的方式del l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] del l[1::2] print(l) # [1, 3, 5, 7, 9] # 使用循环删除，但必须是倒序方式，因为顺序删除时，列表随之改变，会出错 l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] i = len(l)-1 while i > 0: if i % 2 == 1: del l[i] i -= 1 print(l) # [1, 3, 5, 7, 9] l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for i in range(len(l1)-1,-1,-1): if i % 2 == 1: del l[i] print(l) # [1, 3, 5, 7, 9] # 2.range 可定制的数字列表 for i in range(4): print(i) # 0 # 1 # 2 # 3 for i in range(1,4): print(i) # 1 # 2 # 3 for i in range(1,5,2): print(i) # 1 # 3 # 反向取，必须添加步长 for i in range(4,1,-1): print(i) # 4 # 3 # 2 # 3.dict 再循环字典时，不要改变字典的大小。 dic = {'k1':'v1','k2':'v2','k3':'v3','r':666} l1 = [] # 循环字典，将字典中的键添加到列表中 for i in dic: if 'k' in i: l1.append(i) print(l1) # ['k2', 'k3', 'k1'] # 循环列表，删除字典中的键 for i in l1: del dic[i] print(dic) # 4.tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。 tu1 = (1) print(tu1,type(tu1)) # 1 <class 'int'> tu2 = ('string') print(tu2,type(tu2)) # string <class 'str'> tu3 = (['string',1,2]) print(tu3,type(tu3)) # ['string', 1, 2] <class 'list'>
10.小数据池，copy
# 1.对于赋值运算来说，相同值的变量指向的是同一个内存地址，所以他们完全是一样的。 a = 'string' b = 'string' print(a == b) # True print(a is b) # True print(id(a)) # 17922288 print(id(b)) # 17922288 # 2.python中的小数据池 # int -5~ 256的相同的数字全都指向一个内存地址，节省空间 # str：s = 'a' * 20 以内都是同一个内存地址 # 只要字符串含有非字母元素，那就不是一个内存地址 # 3.浅拷贝copy # 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。 l1 = [1, 2, 3, [2, 3, 4]] l2 = l1.copy() print(l1, l2) # [1, 2, 3, [2, 3, 4]] [1, 2, 3, [2, 3, 4]] print(id(l1), id(l2)) # 7625672 7623496 l1[-1].append(5) print(l1, l2) # [1, 2, 3, [2, 3, 4, 5]][1, 2, 3, [2, 3, 4, 5]] print(id(l1), id(l2)) # 7625672 7623496 print(id(l1[-1]),id(l2[-1])) # 7625160 7625160 # 4.深拷贝deepcopy() # 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。 import copy l1 = [1, 2, 3, [2, 3, 4]] l2 = copy.deepcopy(l1) print(l1, l2) # [1, 2, 3, [2, 3, 4]] [1, 2, 3, [2, 3, 4]] print(id(l1), id(l2)) # 11506376 7625672 l1[-1].append(5) print(l1, l2) # [1, 2, 3, [2, 3, 4, 5]] [1, 2, 3, [2, 3, 4]] print(id(l1), id(l2)) # 11506376 7625672
11.编码
# Python 3最重要的新特性之一是对字符串和二进制数据流做了明确的区分。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes，
# 你不能拼接字符串和字节流，也无法在字节流里搜索字符串（反之亦然），也不能将字符串传入参数为字节流的函数（反之亦然）。 # 对于英文 s = 'laonanhai' print(s,type(s)) # laonanhai <class 'str'> s1 = b'laonanhai' print(s1,type(s1)) # b'laonanhai' <class 'bytes'> # 对于中文： s = '中国' print(s,type(s)) # 中国 <class 'str'> s1 = b'\xe4\xb8\xad\xe5\x9b\xbd' print(s1,type(s1)) # b'\xe4\xb8\xad\xe5\x9b\xbd' <class 'bytes'> # 转化 s = 'laonanhai' s2 = s.encode('utf-8') #str -->bytes encode 编码 s3 = s.encode('gbk') print(s2,s3) # b'laonanhai' b'laonanhai' s = '中国' # utf-8中文用三个字节表示一个字符 s2 = s.encode('utf-8') #str -->bytes encode 编码 # gbk中文用两个字节表示一个字符 s3 = s.encode('gbk') print(s2) # b'\xe4\xb8\xad\xe5\x9b\xbd' print(s3) # b'\xd6\xd0\xb9\xfa' ss = s2.decode('utf-8') # bytes ---> str decode 解码 print(ss) # 中国
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
