Python基础-----数据类型

  1 #!/usr/bin/env python 3.7

# -*- coding:utf-8 -*-

# python中有如下数据类型：数字、字符串、列表、字典、元组、布尔值
#
# 一、整型数字（int）
#     1、应注意：
#         a.在python2中分为整型和长整型（long），是根据数字大小区分
#         b.在pycharm中输入相关类型名如int，然后按住ctrl键点击鼠标左键就可看到该类型的所有方法
#     2、方法：
#           a. - int(sub)
#                 可用来转换数据类型，例如可将字符串中的数字转为整型数字：
#                     s = '123'
#                     i = int(s)
#                     >>> i = 123
#                     num = '0010'
#                     v = int(num,base = 2)----(base =2 则表示将num以2进制转换为10进制)
#                     >>> v = 2
#                     v = int(num,base = 10)----(base =10 则表示将num以10进制转换为10进制)
#                     >>> v = 10
#           b. - sub.bit_length()
#                 可用来计算数字用二进制（注：不计算前面的补0位数）表示所需的位数
#                     age = 3   (3的二进制为  11  )
#                     age.bit_length()
#                     >>> 2
#                     age = 5   (5的二进制为  101)
#                     age.bit_length()
#                     >>> 3
# 二、字符串（str）
#     1、字符串一般以引号引起来，引号内的内容即为字符串；
#     2、字符串中的字符不可修改；
#     3、方法：
#         a. str.capitalize()
#             用于将字符串首字母转换为大写。
#             name = "liming"
#             name.capitalize()
#             >>>"Liming"
#         b. 1>sr.casefold()
#            2>sr.lower()
#             上述两个方法用于将字符串中的大写字母转换为小写，但casefold()功能更大，可将很多未知的对应关系进行大小写转换
#         而lower()只能简单的平时遇到的英文等。
#             name = "liMinG  "
#             name.casefold()
#             >>> "liming"
#             name.lower()
#             >>> "liming"
#         c. 1>str.center(width[,fillchar])
#             用于将字符串指定为指定宽度，并将str居中，两边用fillchar字符填充，fillchar为可选项，若没有则以空格填充。
#             name = "Hello"
#             name.center(15,"*")
#             >>>"*****Hello*****"
#             2>str.ljust(width[,fillchar])
#             用于将字符串指定为指定宽度，并将str居左，右边用fillchar字符填充，fillchar为可选项，若没有则以空格填充。
#             name = "Hello"
#             name.ljust(15,"*")
#             >>>"Hello**********"
#             3>str.rjust(width[,fillchar])
#             用于将字符串指定为指定宽度，并将str居右，左边用fillchar字符填充，fillchar为可选项，若没有则以空格填充。
#             name = "Hello"
#             name.rjust(15, "*")
#             >> > "**********Hello"
#             4>str.zfill(width)
#             用于将字符串指定为指定宽度，并以0填充在str前面形成长度为width的字符串。
#             name = "Hello"
#             name.zfill(15)
#             >> > "0000000000Hello"
#         d. str.count(sub[,start[,end]])
#             用于统计字符串str中的sub出现的次数，返回一个int。其中start用于指定开始位置，end用于指定结束位置，二者均为可选项，
#         若没有指定则默认统计整个字符串。(start=< [指定的位置] <end)
#             name = "hello world"
#             name.count("o")
#             >>> 2
#             name.count("o",5,11)
#             >>> 1
#         e. 1>str.startswith(sub[,start[,end]])
#            2>str.endswith(sub[,start[,end]])
#             上诉两个方法分别用于判断字符串str是否以子序列sub作为开始或者结束，返回一个布尔值。其中start用于指定开始位置，
#         end用于指定结束位置，二者均为可选项， 若没有指定则默认统计整个字符串。(start=< [指定的位置] <end)
#             name = "Hello"
#             name.startswith("H")
#             name.expandtabs()
#             >>>True
#             name.endswith("lo")
#             >>>True
#         f. str.expandtabs([tabsize = int])
#             用于（断句）将字符串中"	"转换为指定宽度的tab键分割，默认一个tab = 8个空格。
#             name = "Hel	lo"
#             name.expandtabs(2)
#             >>>"Hel  lo"
#         g. str.find(sub[,start[,end]])
#             用于查找字符串str中的子序列sub在字符串的位置，从开始往后找，返回一个位置int，如果没找到，返回 -1 。
#         其中start用于指定开始位置，end用于指定结束位置，二者均为可选项，若没有指定则默认统计整个字符串。(start=< [指定的位置] <end)
#             name = "Hello"
#             name.find("e")
#             >>> 1
#             name.find("l")
#             >>> 2
#             name.find("l",3,4)
#             >>> 3
#         h. str.format()
#             用于格式化字符串（传值），用于传递大括号{}内的内容，有多种方式：
#             ①按照变量名传递
#                 st = "I am {name},age {age}"
#                 info = st.format(name = "Liming",age = 18)
#                 print(info)
#                 >>> "I am Liming,age 18"
#
#             ②按照索引（从0开始）传递
#                 st = "I am {0},age {1}"
#                 info = st.format("Liming",18)
#                 print(info)
#                 >>> "I am Liming,age 18"
#         i. str.format_map()
#             用于格式化字符串（传值），用于传递大括号{}内的内容，是以字典的形式进行传递：
#                 st = "I am {name},age {age}"
#                 info = st.format_map({"name":"Liming","age":18})
#                 print(info)
#                 >> > "I am Liming,age 18"
#         j. str.inainum()
#             判断字符串至少有一个字符，且是否只由数字或字母或二者组合组成，若为判断成立则输出True，反之则双输出False
#                 st = "abc123a"
#                 st.isalnum()
#                 >>> True
#         k. str.isalpha()
#             判断字符串至少有一个字符，且是否只由字母或者汉字或者二者组合组成（中英文），若为判断成立则输出True，反之则双输出False
#                 st = "abc123a"
#                 st.isalpha()
#                 >>> False
#                 st = "abcd"
#                 st.isalpha()
#                 >>> True
#                 st = "你好"
#                 st.isalpha()
#                 >> > True
#         l. 1> str.isdigit()
#             判断字符串是否只由十进制数字组成，若为判断成立则输出True，反之则双输出False
#             >>满足①True：Unicode数字、byte数字（单字节）、全角数字（双字节）、罗马数字
#             >>    ②False:汉字数字
#             >>    ③Error：无
#                 st = "1234"
#                 st.isdigit()
#                 >>> True
#                 st = "四"
#                 st.isdigit()
#                 >>> False
#            2> str.isdecimal()
#             判断字符串是否只由数字组成，若为判断成立则输出True，反之则双输出False
#             >> 满足①True：Unicode数字、全角数字（双字节）
#             >>     ②False: 汉字数字、罗马数字
#             >>     ③Error：byte数字（单字节）
#                 st = "1234"
#                 st.isdigit()
#                 >> > True
#                 st = "IV"
#                 st.isdigit()
#                 >> > False
#            3> str.isnumeric()
#             判断字符串是否只由数字组成，若为判断成立则输出True，反之则双输出False
#             >> 满足①True：Unicode数字、全角数字（双字节）、罗马数字、汉字数字
#             >>     ②False: 无
#             >>     ③Error：byte数字（单字节）
#                 st = "1234"
#                 st.isnumeric()
#                 >>> True
#                 st = "四"
#                 st.isnumeric()
#                 >>> True
#         m. str.isidentifier()
#             用于检测字符串是否满足变形名的标识符，是则返回True，反之返回False
#                 st = "abc11"
#                 st.isidentifier()
#                 >>> True
#                 st = "123aaa"
#                 st.isidentifier()
#                 >>> False
#                 st = "_123aa"
#                 st.isidentifier()
#                 >>> True
#         n. str.isprintable()
#             用于检测字符串中是否有不可显示（print）的字符(	  
等），如有返回False，反之True
#                 st = "qqw	3112"
#                 st.isprintable()
#                 >>> False
#         o. str.isspace()
#             用于检测字符串是否全部由空格字符串组成（不是空字符串），是则返回True，反之False
#                 st = ""
#                 st.isspace()
#                 >>> False
#                 st = "   "
#                 st.isspace()
#                 >>> True
#         p. str.istitle()
#             用于检测字符串是否为标题（即为字符串中每个单词是否首字母大写），是则返回True，反之False
#             （可用str.title()将字符串转换为标题格式）
#                 st = "Abc is B"
#                 st.istitle()
#                 >>> False
#                 st = "Abc Is B"
#                 st.istitle()
#                 >>> True
#         q. sub.join(str)
#             以sub字符串作为拼接符，将str字符串中的每一个元素进行拼接
#                 sub = "_"
#
#                 str = "ABCDEFG"
#                 str_sub = sub.join(str)
#                 >>> "A_B_C_D_E_F_G"
#         r. 1>str.islower()
#             检测字符串是否均为小写，是则返回True，反之False
#                 st = "AcccSd"
#                 st.islower()
#                 >>> False
#            2>str.lower()
#             用于将字符串中的每个字母转换为小写。
#                 st = "AcccSd"
#                 st.lower()
#                 >>> "accsd"
#         s. 1>str.isupper()
#             检测字符串是否均为大写，是则返回True，反之False
#                 st = "AcccSd"
#                 st.isupper()
#                 >>> False
#                 st = "ADDFA"
#                 st.isupper()
#                 >>> True
#            2>str.upper()
#             用于将字符串中的每个字母转换为大写。
#                 st = "AcccSd"
#                 st.upper()
#                 >>> "ACCCSD"
#         t. 1>str.strip([char])
#             ①char为可选项，若不指定，则去清除字符串中首尾不显示的内容：空格，	，
等，对于字符串中间的空白内容无效。
#                 st = " A BCDD  "
#                 st.strip()
#                 >>> "A BCDD"
#                 st = "   	AV  DC
  "
#                 st.strip()
#                 >>> "AV  DC"
#             ②若指定char，则会比对char中的字符与str中的字符，从两边进行清除char和str相同的字符（优先最多匹配）。
#                 st = "ABCDBA"
#                 st.strip("AB")
#                 >> > "CD"
#            2>str.lstrip()
#             ①用去清除字符串中左边不显示的内容：空格，	，
等；
#                 st = " A BCDD  "
#                 st.lstrip()
#                 >>> "A BCDD  "
#             ②同上②
#            3 > str.rstrip()
#             ①用去清除字符串中右边不显示的内容：空格，	，
等；
#                 st = " A BCDD  "
#                 st.rstrip()
#                 >>> " A BCDD"
#             ②同上②
#         u. 1>str.maketrans(str1,str2)
#             用于制造替换的对应关系
#                 o = "abecimoku"
#                 a = "aeiou"
#                 b = "12345"
#                 c = str.maketrans(a,b)
#                 (c返回的是一个字典，a、b对应的asccii值)、
#            2>str.translate(str.maketrans(str1,str2))
#             结合上述的str.maketrans(str1,str2)生成的对应关系，而对新的字符串按此规则进行替换
#                 d = c.translate(c)
#                 >>> "1b2c3m4k5"
#         v. 1>str.partition(char)   str.rpartition()
#             用于以指定的char作为分隔符并且包含char进行分割，分割为三部分（char必须指定）
#                 a = "abdcbf"
#                 b = a.partiton("b")
#                 >>> ["a","b","dcbf"]
#                 c = a.rpartition("b")
#                 >>> ["abdc","b","f"]
#            2>str.spilt(char[,maxnum = -1])  str.rspilt(char[,maxnum = -1])
#             用于以指定的char作为分隔符并且分割出不包含char进行分割；maxnum为可选项，默认为-1，则表示全部分割
#             0表示不分割，1表示分割为两份，2为三份，以此类推
#                 a = "abdcbf"
#                 b = a.split("b")
#                 >>> ["a","dc","f"]
#                 b = a.split("b",0)
#                 >>> ["abdcbf"]
#                 b = a.split("b",1)
#                 >>> ["a","dcbf"]
#                 c = a.rsplit("b",1)
#                 >>> ["abdc","f"]
#            3>str.splitlines([False])
#              以"
"作为分隔符进行分割，有True，False可选，默认为False；True则分割的字符串包含"
"，False则不包含。
#                 a = "abcd
acfd
adsa"
#                 b = a.splitlines()
#                 >>> ["abcd","acfd","adsa"]
#                 b = a.splitlines(True)
#                 >>> ["abcd
","acfd
","adsa"]
#         w. str.swapcase()
#              将字符串中的大写字符转换为小写，小写转换为大写。
#                 a = "aBcdE"
#                 b = a.swapcase()
#                 >>> "AbCDe"
#         x. str.replace(old,new[,count])
#              将字符串中的old字符或者子序列替换为new，指定count则替换不超过count此；默认不指定则表示全部替换。
#                 a = "helloworld"
#                 old = "l"
#                 new = "L"
#                 b = a.replace(old,new)
#                 >>> "heLLoworLd"
# 三、列表（list）
#     0、列表中的元素均有索引对应，所以说列表是有序的；
#     1、列表是以中括号[]引起来，并且以“,”分隔；列表中的元素可以是数字（int）、字符串（str）、列表（list）、布尔值（bool）等；
# 即所有的对象均可以放入列表；
#     2、同样可以用索引和切片进行取值或者修改；
#         a = [1,2,3,4]
#         a[1] = 222
#         print(a)
#         >>> [1,222,3,4]
#     3、列表内容是可以被修改（删除、增加、插入等）；
#     4、可以用in来判断某一元素是否存在列表中；
#     5、字符串同样可以转换为列表（可以理解为在字符串中使用for循环将对象添加至列表）。反之若要将列表转换为字符串的话，①需要自己
# 写for循环来迭代处理（针对列表中既有数字又有字符串）；②若列表中只有字符串元素，则可以用join方法进行转换拼接；
#         a = "abcdefg"
#         b = list(a)
#         >>> ['a','b','c','d','e','f','g']
#         c = ['1',1,'a']
#         d = ""
#         for i in c:
#             d += str(i)
#         print(d)
#         >>> "11a"
#         e = ['a','b','1']
#         d = ''.join(e)
#         >>> "ab1"
#     6、list的相关方法：
#            a. list.append(sub)
#             用于向列表末尾追加（增添）整个的元素sub，sub可以是任意对象（因为列表是可修改的，所以该方法直接使用，不需要重新赋值）。
#                 a = ['a','c']
#                 a.append('b')
#                 print(a)
#                 >>> ['a','c','b']
#             b. list.clear()
#             用于清空列表（删除列表中所有元素，返回的是空列表）（因为列表是可修改的，所以该方法直接使用，不需要重新赋值。）。
#                 a = ['a','c']
#                 a.clear()
#                 print(a)
#                 >>> []
#             c. list.copy()
#             用于复制（拷贝【浅拷贝】）列表，返回一个元素相同的新列表，需要有变量来接收。
#                 a = ['a','c']
#                 b = a.copy()
#                 print(b)
#                 >>> ['a','c']
#             d. list.count(sub)
#             用于计算列表中的某一元素sub出现的次数，返回一个int，需要有变量来接收。
#                 c = [1,2,3,1,1]
#                 d = c.count(1)
#                 print(d)
#                 >>> 3
#             e. list.extend(iterable)
#             用于扩展原列表，向列表中追加（增添）一个可迭代对象iterable对象的每一个元素。这个可迭代对象可以是列表或者字符串
#         等的任意可迭代对象（因为列表是可修改的，所以该方法直接使用，不需要重新赋值），与append()方法不同的是，它是将可迭代
#         对象的每个元素迭代添加到原列表中，而appen()是将传入的对象（无论是否为可迭代对象）作为整体添加到原列表中。
#                 a = ['a','c']
#                 a.extend(['b','d'])
#                 print(a)
#                 >>> ['a','c','b','d']
#                 a = ['a','c']
#                 a.extend("def")
#                 print(a)
#                 >>> ['a','c','d','e','f']
#                 a = ['a','c']
#                 a.append(['b', 'd'])
#                 print(a)
#                 >>> ['a','c',['b', 'd']]
#             f. list.index(sub[,start[,end]])
#             用于查找列表中某一元素sub的索引值（左边优先，即为从左往右查找，找到即返回索引值），同样可以指定查找的起始和结束位置
#         ，返回int，需用变量接收；弱若传入的sub不在查找的列表中则报错。
#                 a = [1,2,3,2,1]
#                 b = a.index(1)
#                 print(b)
#                 >>> 0
#                 a = [1, 2, 3, 2, 1]
#                 b = a.index(2,2,4)
#                 print(b)
#                 >>> 3
#             g. list.insert(index,sub)
#             用于向列表中插入元素，index指定插入位置的索引，sub为插入的元素。
#                 a = [1,2,4,5]
#                 a.index(0,6)
#                 print(a)
#                 >>> [6,1,2,4,5]
#             h. list.pop([index])
#             用于删除指定索引的元素，若不指定index，则默认删除最后一个元素，并获取删除的值。
#                 a = [1,2,4,5]
#                 b = a.pop()
#                 print(a)
#                 >>> [1,2,4]
#                 print(b)
#                 >>> 5
#                 c = a.pop(1)
#                 print(c)
#                 >>> [1,4,5]
#             i. list.remove(sub)
#             用于删除指定元素（左边优先）。
#                 a = [1,2,4,5]
#                 a.remove(4)
#                 print(a)
#                 >>> [1,2,5]
#             j. del list
#             注意del是一个语句，不是列表的方法，所以不必加（）；若del后加的是列表名，则表示删除整个列表；若del后加的是
#         列表切片或者索引则删除指定切片或者索引内容。
#                 a = [1,2,3,4]
#                 del a
#                 print(a)
#                 >>> []
#                 b = ['a','b','c']
#                 del b[1]
#                 print(b)
#                 >>> ['a','c']
#             k. list.reverse()
#             用于反转列表。
#                 a = [1,2,3,4]
#                 a.reverse()
#                 print(a)
#                 >>> [4,3,2,1]
#             l. list,sort([reverse = False])
#             用于对列表元素排序，可选项reverse默认为False表示不反转排序（即从小到大排序），反之若reverse = True，则从大到小。
#                 a = [2,5,3,1,4]
#                 a.sort()
#                 print(a)
#                 >>> [1,2,3,4,5]
#                 a.sort(reverse = True)
#                 print(a)
#                 >>> [5,4,3,2,1]
# 四、元组（tuple）
#     0、元组也是有序的；
#     1、元组是用()括起来的对象，元组中内容可以是str，int，list，tuple，bool等；
#         a = (1,'avc',[1,2,3],True,(1,3,4))
#     2、元组一旦被创建，其中的整体（一级）元素不可被修改（但是若元组中有一个列表元素，则可以对该元素修改），不能被增加或者删除；
#         a = (1,'avc',[1,2,3],True,(1,3,4))
#         a[2][0] = 111
#         print(a)
#         >>> (1,'avc',[111,2,3],True,(1,3,4))
#         a = (1,'avc',[1,2,3],True,(1,3,4))
#         a[0] = 111
#         则会直接报错！！！~
#     3、一般写元组的时候，推荐在最后加“,”；
#     4、元组同样可以通过索引和切片访问（取值）元素；
#     5、元组同样可以用For循环；
#     6、字符串、列表同样可以用tuple()方法转换为元组；元组可以转换为列表；
#     7、元组的基本方法：
#         a. tuple.count(sub)
#         用于获取指定元素在元组中出现的次数，返回一个int对象
#             tu = (1,2,3,2,1)
#             co = tu.count(1)
#             print(co)
#             >>> 2
#         b. tuple.index(sub)
#         用于获取元组中元素的索引（若元组中有多个相同的元素，则同样遵从左边优先规则），返回一个int对象
#             tu = ('a','b','a',)
#             co = tu.index('a')
#             print(co)
#             >>> 0
#五、字典
#     1、字典是用{}括起来的对象（键值对）；
#         di = {'a':'1','b':'2'}
#         其中 'a':'1' 为字典中的一个键值对， 'a'为字典的Key，'1'为字典的value
#     2、元组中的value内容可以是str，int，list，tuple，bool，dict等；list、dict不能作为字典的key；
#     3、字典是无序的；
#     4、字典可以通过key获取相应value；
#         di = {'a':'1','b':'2'}
#         dia = di['a']
#         print(dia)
#         >>> '1'
#     5、字典同样支持del删除指定的键值对；
#         di = {'a':'1','b':'2'}
#         del di['a']
#         print(di)
#         >>> ['b':'2']
#     6、字典可以进行for循环，默认根据key进行循环；
#         di = {'a':'1','b':'2'}
#         for i in di:
#             print(i)
#         >>> 'a'
#             'b'
#         也可以的用字典的内置方法dict.keys()来获取字典的key值：
#         di = {'a': '1', 'b': '2'}
#         for k in di.keys():
#             print(i)
#         >>> 'a'
#             'b'
#         若想要获取字典的value值，可以用内置方法dict.values()：
#         di = {'a': '1', 'b': '2'}
#         for v in di.values():
#             print(i)
#         >>> '1'
#             '2'
#         若想同时获取key和value则可以用内置方法dict.items()：
#         di = {'a': '1', 'b': '2'}
#         for k,v in di.items():
#             print(k,v)
#         >>> 'a' '1'
#             'b' '2'
#     7、字典的基本方法：
#         a. dict.clear()
#         用于清空字典
#             di = {'a': '1', 'b': '2'}
#             di.clear()
#             print(di)
#             >>> {}
#         b. dict.copy()
#         用于复制（浅拷贝）字典
#             di = {'a': '1', 'b': '2'}
#             d = di.copy()
#             print(d)
#             >> > {'a': '1', 'b': '2'
#         c. dict.fromkeys(iterable[,value])
#         该方法为静态方法（暂不懂），根据一个可迭代对象创建一个字典，并指定统一的值（若不传入，则为None）
#     第一个参数作为key，第二个参数作为value值
#             di = dict.fromkeys(['a','b''c'])
#             print(di)
#             >>> {'a':None,'b':None,'c':None}
#             di = dict.fromkeys(['a','b''c'],'abc')
#             print(di)
#             >>> {'a':'abc','b':'abc','c':'abc'}
#         d. dict.get(key[,value])
#         用于根据key获取值，若key不存在，可以指定默认值，若不指定则返回None
#             di = {'a': '1', 'b': '2'}
#             v = di.get('a')
#             print(v)
#             >>> '1'
#             若取的值不存在有如下情况：
#             di = {'a': '1', 'b': '2'}
#             v = di.get('aa','abcd')
#             print(v)
#             >>> 'abcd'
#         而通过索引key来取值，若key不存在，则报错。
#         e. dict.pop(key[,value])
#         用于移除并获取到指定指定的key对应的值，若key不存在，则返回指定的value值
#             di = {'a': '1', 'b': '2'}
#             v = di.pop('a')
#             print(di,v)
#             >>> {'b':'2'} '1'
#         若指定的key不存在，则传入的value值可起到作用而不报错
#             di = {'a': '1', 'b': '2'}
#             v = di.pop('c','3')
#             print(di, v)
#             >> > {'a':'1','b': '2'} '3'
#         f. dict.popitem()
#         用于随机删除并获取键值对
#             di = {'a': '1', 'b': '2'}
#             v = di.popitem()
#             print(di,v)
#             >>> {'a':'1'} ('b',2)
#         g. dict.setdefault(key,value)
#         用于设置值，若key已存在在当前字典中，则设置无效并返回当前key的值；若key不存在，则设置将指定的key，value添加到字典中
#             di = {'a': '1', 'b': '2'}
#             v = di.setdefault('a','111')
#             print(di,v)
#             >>> {'a':'1','b':'2'} '1'
#             v1 = di.setdefault('c','3')
#             print(di,v1)
#             >>> {'a':'1','b':'2','c':'3'} '3'
#         h. dict.update({key:value})
#         用于更新字典，key存在则更新指定的值，若不存在则直接添加到字典中
#         ①可以直接传入字典形式
#             di = {'a':'1','b':'2'}
#             di.update({'a':'111','c':'3'})
#             print(di)
#             >>> {'a':'111','b':'2','c':'3'}
#         ②可以指定key和value的形式进行传入
#             di = {'a':'1','b':'2'}
#             di.update(a = '111',c = '3')
#             print(di)
#             >>> {'a':'111','b':'2','c':'3'}
# 六、布尔值（bool）
#         在内存中bool值是以0 1存储的，0为False，1为True
#         还有None '' () [] {}这些均为False
#         bool(对象)可用于将对象转换为bool值
# 七、enumerate(iterable[,startint])方法
#     该方法可用作获取列表、元组或者字典等元素的值与其对应的位置（或者索引），默认从0开始，也可以指定
# li = ['a','b','c','d','e']
# for i,v in enumerate(li,1):
#     print(i,v)