# -*- 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])
用于（断句）将字符串中"\t"转换为指定宽度的tab键分割，默认一个tab = 8个空格。
name = "Hel\tlo"
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）的字符(\t \n等），如有返回False，反之True
# st = "qqw\t3112"
# 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为可选项，若不指定，则去清除字符串中首尾不显示的内容：空格，\t，\n等，对于字符串中间的空白内容无效。
# st = " A BCDD "
# st.strip()
# >>> "A BCDD"
# st = " \tAV DC\n "
# st.strip()
# >>> "AV DC"
# ②若指定char，则会比对char中的字符与str中的字符，从两边进行清除char和str相同的字符（优先最多匹配）。
# st = "ABCDBA"
# st.strip("AB")
# >> > "CD"
# 2>str.lstrip()
# ①用去清除字符串中左边不显示的内容：空格，\t，\n等；
# st = " A BCDD "
# st.lstrip()
# >>> "A BCDD "
# ②同上②
# 3 > str.rstrip()
# ①用去清除字符串中右边不显示的内容：空格，\t，\n等；
# 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])
# 以"\n"作为分隔符进行分割，有True，False可选，默认为False；True则分割的字符串包含"\n"，False则不包含。
# a = "abcd\nacfd\nadsa"
# b = a.splitlines()
# >>> ["abcd","acfd","adsa"]
# b = a.splitlines(True)
# >>> ["abcd\n","acfd\n","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)
Python基础-----数据类型
©著作权归作者所有,转载或内容合作请联系作者
- 文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
- 文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
- 文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
推荐阅读更多精彩内容
- 文/杨晓丹 陆雪 汤峻峰 12月17日，由校团委主办、创新创业实践协会承办的首届“新道杯”校园ERP企业沙盘模拟经...
