2.基本数据类型

Posted 2020-09-18 龚旭1994

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了2.基本数据类型相关的知识，希望对你有一定的参考价值。

文件类型

类型	type	创建方法
数字	int可变	a = 1
字符串	str可变	a = ("asv") 注:多个元素就是元组
元组	tuple不可变	b = ("asv","aed",21)
列表(有序)	list可变	c = ["asv","aed",21]
字典(无序)	dict可变	d ={"v1":"bb","v2":"b3"}
集合(无序)	set可变	se = {"one","tow","three"}

文件类型转换

a = "xxx"
print(a)     #字符串类型
print(list(a))    #字符串转列表
print(tuple(a))    #字符串转元组
b = ["aa","bb","cc"] #列表
b=str(tuple(b)) #列表转元组
print(b)
d = ("aa","bb","c") #元组
d = str(list(d)) #元组转列表
print(d)

数字

int 整型

Python的整型相当于C中的long型,Python中的整数可以用十进制,八进制,十六进制表示。

>>> 10
10         --------->默认十进制
>>> oct(10)
\'012\'      --------->八进制表示整数时，数值前面要加上一个前缀“0”
>>> hex(10)
\'0xa\'      --------->十六进制表示整数时，数字前面要加上前缀0X或0x

python2.*与python3.*关于整型的区别

python2.*
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
python3.*整形长度无限制

Long 长整型 pytyon3没有

python2.*：
跟C语言不同，Python的长整型没有指定位宽，也就是说Python没有限制长整型数值的大小，
但是实际上由于机器内存有限，所以我们使用的长整型数值不可能无限大。
在使用过程中，我们如何区分长整型和整型数值呢？
通常的做法是在数字尾部加上一个大写字母L或小写字母l以表示该整数是长整型的，例如：
a = 9223372036854775808L
注意，自从Python2起，如果发生溢出，Python会自动将整型数据转换为长整型，
所以如今在长整型数据后面不加字母L也不会导致严重后果了。

python3.*
长整型，整型统一归为整型

python2.7
>>> a=9223372036854775807
>>> a
9223372036854775807
>>> a+=1
>>> a
9223372036854775808L

python3.5
>>> a=9223372036854775807
>>> a
9223372036854775807
>>> a+=1
>>> a
9223372036854775808
复制代码

Float 浮点数 1个浮点数占8字节(64位) 浮点数:带有小数的整数)

Python的浮点数就是数学中的小数，类似C语言中的double。
在运算中，整数与浮点数运算的结果是浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，
一个浮点数的小数点位置是可变的，比如，1.23*109和12.3*108是相等的。
浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，
就必须用科学计数法表示，把10用e替代，1.23*109就是1.23e9，或者12.3e8，0.000012
可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的而浮点数运算则可能会有
四舍五入的误差。

bool布尔 (判断真或假 ) 1==True 0==False (只有0是False 其他都是True)

    判断a列表是否存在元素
    >>> a =[\'aa\',\'cc\']
    >>> "bb" in a
    True
    >>> "dd" in a
    False

复数complex

复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
注意，虚数部分的字母j大小写都可以，

复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
注意，虚数部分的字母j大小写都可以，

>>> 1.3 + 2.5j == 1.3 + 2.5J
True

数字相关内建函数

字符串

定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，‘’或“”或‘’‘ ’‘’中间包含的内容称之为字符串
特性：
    1.只能存放一个值
    2.不可变
    3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
补充：
　　1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r\'l\\thf\'
　　2.unicode字符串与r连用必需在r前面，如name＝ur\'l\\thf\'

strip移除空白

    >>> msg14=" adf " #前后有空格
    >>> print(msg14.strip()) #去掉左右空格,()内可加字符
    adf
    >>> print(msg14.rstrip()) #去掉右空格
    adf
    >>> print(msg14.lstrip()) #去掉右空格
    adf

split 分割

>>>user_1 = "aex|sb123|9"
>>>v = user_1.split("|")   #分割所有,以|为分开
>>>print (v)
[\'aex\', \'sb123\', \'9\']
>>>v = user_1.split("|",1) #分割第一个,从左边分割
>>>print (v)
[\'aex\', \'sb123|9\']
>>>v = user_1.rsplit("|",1)#分割第一个,从右边分割
>>>print (v)
[\'aex|sb123\', \'9\']

长度 len(name)

    按字符算 不是字节
    >>> msg17=("abc ","aa") #多个元素显示元素个数,单个元素显示字符串个数
    >>> print(len(msg17))
    2
    >>> msg17=("abc")
    >>> print(len(msg17))
    3

索引 name[2]

    >>> name
    [11, \'ad\', 33]
    >>> name[2]
    33

切片 a[:3] 或a[3:]或a[3]

    >>> msg="nihao 123"
    >>> print(msg[1]) #范围 取位置1的值
    i
    >>> print(msg[2:5]) #:表示顺序延伸 范围 取位置2-4的值 顾头不顾尾不取位置4的值
    hao
    >>> print(msg[0:]) #:表示顺序延伸 范围 所有位置的值
    nihao 123
    >>> print(msg[0:-1]) #:表示顺序延伸 范围取值0到-2的值 顾头不顾尾不取位置-1的值
    nihao 12

capitalize 首字母大写

    >>> msg="hello world"
    >>> print(msg.capitalize())
    Hello world

casefold  大写变小写

    >>>name =\'AabbCc\'
    >>>v = name.casefold() #lower也能实现 但不如casefold功能多,一般用casefold
    >>>print(v)
    aabbcc
    -------------------
    lower
    >>>aa = ("AaBbCc")
    >>>aa=aa.lower()
    >>>print(aa)
    aabbcc

swapcase 小写转大写

    swapcase
    >>> name = "atlex"
    >>> result =name.swapcase()
    >>> print(result)
    ATLEX
    ----------------------
    upper

    >>>aa = ("AaBbCc")
    >>>aa=aa.upper()
    >>>print(aa)
    AABBCC

center分割行

    >>> mss="abc"
    >>> print(msg.center(20)) #20是总长度,默认空行是内容
    abc
    >>> print(msg.center(20,"*")) #20是总长度,*行内容 *长度为1    print("msg".center(20,"*")) #加"" 不用定义变量
    *******abc********
    >>> print(msg.ljust(20,"*")) #20是总长度右边填充*
    abc******
    >>> print(msg.rjust(20,"*"))  #20是总长度左边填充*
    ******abc

count统计元素出现的次数

    >>>name = "dfdfdaa,df,adsfasdfaga"
    >>>result = name.count("df",0,10) #统计:df出现的次数 范围:0-9个字符(有头无尾),注:不加0-10是统计所有字符
    >>>print (result)
    2
    >>>result = name.count("df",0,-1) 右边第一个到左边第0个中间的df个数
    >>>print (result)
    3

encode utf-8转gbk

>>>name ="理解"
>>>result= name.encode("gbk")
>>>print(result)
b\'\\xc0\\xed\\xbd\\xe2\'

endswith判断结尾数字 startswith判断结尾数字

    >>> name ="adfasdfs"
    >>> result= name.endswith("fs") #是否以fs结尾
    >>> result= name.endswith("s",0,5) #以s结尾 范围是大于等于0 小于5 判断是否为真
    >>> print(result)
    True
     
    >>> name ="adfasdfs"
    >>> result= name.startswith("ad") #是否以ad开头
    >>> result= name.startswith("a",0,5) #以s开头 范围是大于等于0 小于5 判断是否为真
    >>> print(result)
    True

expandtabs增加分割符

>>> name = "a\\tlex"

>>>name = "a\\tlex\\tguolm\\tqiqi\\na\\tb" ##\\t是制表符,\\n换行符

>>>result =name.expandtabs(20)        #20是\\t的行间距

>>>print(result)

partition字符分割

    >>> name ="alexissb"
    >>> result= name.partition("is") #指定is为分割,分割成3段
    >>> print(result)
    (\'alex\', \'is\', \'sb\')

find和index 查找字符串

    >>> msg14="hello"
    >>> print(msg14.find("o")) #find 查找到元素,返回元素位置
    4
    >>> print(msg14.find("a")) #find 查找不到元素,返回-1
    -1
    >>> print(msg14.index("o")) #index 查找到元素,返回元素位置
    4
    >>> print(msg14.index("a")) #index 查找不到元素,报错
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    ValueError: substring not found

enumerate 定义下标

    >>>li= ["eric","alex","tony"]
    >>>for i,ele in enumerate(li,1):    #1是指定第一次为1, 不指定下标默认为零
    >>> print(i,ele)
    1 eric 2 alex 3 tony
    >>>v=input("请输入商品序号")
    >>>v=int(v)
    >>>item = li[v-1]                #v-1表示:是数字v减1 ,因为定义序列下标为1, 如上使用默认就不用v-1
    >>>print(item)

join元素拼接

    >>> msg="aa哈站"
    >>> v="_".join(msg)
    >>> print(v)
    a_a_哈_站

    >>> name=["aa","bb","cc"]  #不能有数字 都是字符串
    >>> v="_".join(name)        #_可替换  只要for能循环的 .join都能用
    >>> print(v)
    aa_bb_cc

format 拼接(事实上Format方法有两个种形式，另外一种是三个参数的，主要区别在于它是线程安全的，)

#常用方法：

print(\'{0},{1}\'.format(\'zhangk\', 32))
print(\'{},{},{}\'.format(\'zhangk\',\'boy\',32)) 
print(\'{name},{sex},{age}\'.format(age=32,sex=\'male\',name=\'zhangk\'))
print(\'{name},{gender},{age}\'.format(age=3,gender=\'female\',name=\'Alex\'))

# 填充与对齐
# 填充常跟对齐一起使用
# ^、<、>分别是居中、左对齐、右对齐，后面带宽度
# :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
 
print(\'{:>8}\'.format(\'zhang\'))
print(\'{:0>8}\'.format(\'zhang\'))
print(\'{:a<8}\'.format(\'zhang\'))
print(\'{:p^10}\'.format(\'zhang\'))


# 精度与类型f
# 精度常跟类型f一起使用
print(\'{num:.3f}\'.format(num=5))


# 其他类型
# 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制
print(\'{:b}\'.format(15))
print(\'{:d}\'.format(15))
print(\'{:o}\'.format(15)) 
print(\'{:x}\'.format(15))
 
# 用逗号还能用来做金额的千位分隔符
print(\'{:,}\'.format(123456789))
print(\'{:,.2f}\'.format(123456789))

##print_res:
##Alex,female,3
##5.000
##1111
##15
##17
##f
##123,456,789
##123,456,789.00

#我的案例：打印等腰三角形：

def print_trigle(n:int):
    format_str=\'{:^\'+str(n)+\'}\'
    for i in range(1,n+1,2):
        print(format_str.format(\'*\'*i))
print_trigle(21)

##         *          
##        ***         
##       *****        
##      *******       
##     *********      
##    ***********     
##   *************    
##  ***************   
## *****************  
##*******************

isalnum判断值是否由数字和字母或纯数字或纯字母组成

    >>> msg="12aa" ##"aAaa" "122"都为true真
    >>> print(msg.isalnum())
    True
    >>> msg="122_aa"
    >>> print(msg.isalnum())
    False

isdigit判断值为数字,整形(整数)

    >>>ms=11
    >>> print(ms.isdigit())
    True真
    >>> ms="101.1"
    >>> print(ms.isdigit())
    False假    #错误

isalpha判断值由字母组成

    >>> msg="Aaa"
    >>> print(msg.isalpha())
    True
    >>> msg="122_aa"
    >>> print(msg.isalpha())
    False

 1 num = "1"  #unicode
 2 num.isdigit()   # True
 3 num.isdecimal() # True
 4 num.isnumeric() # True
 5 
 6 num = "1" # 全角
 7 num.isdigit()   # True
 8 num.isdecimal() # True
 9 num.isnumeric() # True
10 
11 num = b"1" # byte
12 num.isdigit()   # True
13 num.isdecimal() # AttributeError \'bytes\' object has no attribute \'isdecimal\'
14 num.isnumeric() # AttributeError \'bytes\' object has no attribute \'isnumeric\'
15 
16 num = "IV" # 罗马数字
17 num.isdigit()   # True
18 num.isdecimal() # False
19 num.isnumeric() # True
20 
21 num = "四" # 汉字
22 num.isdigit()   # False
23 num.isdecimal() # False
24 num.isnumeric() # True
25 
26 ===================
27 isdigit()
28 True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
29 False: 汉字数字
30 Error: 无
31 
32 isdecimal()
33 True: Unicode数字，，全角数字（双字节）
34 False: 罗马数字，汉字数字
35 Error: byte数字（单字节）
36 
37 isnumeric()
38 True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
39 False: 无
40 Error: byte数字（单字节）
41 
42 ================
43 import unicodedata
44 
45 unicodedata.digit("2")   # 2
46 unicodedata.decimal("2") # 2
47 unicodedata.numeric("2") # 2.0
48 
49 unicodedata.digit("2")   # 2
50 unicodedata.decimal("2") # 2
51 unicodedata.numeric("2") # 2.0
52 
53 unicodedata.digit(b"3")   # TypeError: must be str, not bytes
54 unicodedata.decimal(b"3") # TypeError: must be str, not bytes
55 unicodedata.numeric(b"3") # TypeError: must be str, not bytes
56 
57 unicodedata.digit("Ⅷ")   # ValueError: not a digit
58 unicodedata.decimal("Ⅷ") # ValueError: not a decimal
59 unicodedata.numeric("Ⅷ") # 8.0
60 
61 unicodedata.digit("四")   # ValueError: not a digit
62 unicodedata.decimal("四") # ValueError: not a decimal
63 unicodedata.numeric("四") # 4.0
64 
65 #"〇","零","一","壱","二","弐","三","参","四","五","六","七","八","九","十","廿","卅","卌","百","千","万","万","亿"

python中str函数isdigit,isdecimal,isnumeric的区别

isspace全是空格

    aa = " "            #只针对字符串
    print(aa.isspace())
    True

isdecimal判断值为十进制

    >>> ms="101"
    >>> print(ms.isdecimal())
    True
    >>> ms="101.1"
    >>> print(ms.isdecimal())
    False

islower判断值全是小写

    >>>ad="aaa"
    >>>print(ad.islower())
    True

isupper判断值全是大写

    >>>ad="AAA"
    >>>print(ad.isupper())
    True

maketrans对应关系替换

    >>> msg16="my name is abcd"
    >>> table=str.maketrans("abcd","1234") #abcd和gulm长度必须相同
    >>> print(msg16.translate(table))
    my ngme is 1234

zfill填充

    >>> msg17="abc"
    >>> print(msg17.zfill(20)) #不够的位数用0填充
    00000000000000000abc

relpace转换,替换

    >>> name ="aaxissb"
    >>> result= name.replace("a","g",2) #a转换成g 范围:前2个,不加数字表示转换全部
    >>> print(result)
    ggxissb

元组

定义：与列表类似，只不过［］改成（）
特性：

1.可存放多个值
2.不可变
3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

元组的元素不能改但是元组的列表的元素可以修改,

元组结尾必须加逗号,

元组的参数count和index a = (\'a\',1,)

count统计元素出现的次数

index 查找字符串(查找不到报错)

元组嵌套字典

    >>> t1 = (1,2,{"gg":"k3"}) #增加了字典
    >>> t1
    (1, 2, {\'gg\': \'k3\'})
    >>> t1[2]["gg"]=2
    >>> t1
    (1, 2, {\'gg\': 2})

列表

定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
特性：
1.可存放多个值
2.可修改指定索引位置对应的值，可变
3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

有序,元素可以更改, 更容易的存取多个信息

 1  L = ["a",11,"var"]
 2     L.append("var") #追加一个,var的值添加到L的中
 3     print(L)
 4 
 5     追加多个元素    extend
 6 
 7     name = ["1","aa","cc","bb","33","22"]
 8     name.extend([55,"qq"])
 9     print(name)
10 
11      
12     插入, 指定追加    insert
13 
14     name = ["aa","var","cc","var","33","22"]
15     name.insert(2,"bb")     #在第三元素后增加bb
16     print(name)
17 
18     pop 指定索引删除元素    默认删除最后一个元素
19 
20     >>>name = ["aa","var","cc","var","33","22"]
21     >>>name.pop()      #默认删除最后一个元素
22     >>>print(name)
23     [\'aa\', \'var\', \'cc\', \'var\', \'33\']
24     >>>test = ["aa","var","cc","var","33","22"]
25     >>>test.pop(0)     #指定可指定索引删除,0是第一个索引
26     >>>print(test)
27     [\'var\', \'cc\', \'var\', \'33\', \'22\']
28 
29      
30     remove    删除,指定删除元素var 如有多个var 删除第一次出现元素var    
31 
32     name = ["1","var","cc","var","33","22"]
33     name.remove("var")
34     print(name)
35 
36     del 根据索引删除
37 
38     name = ["a",11,"var","cc","22","aaa"]
39     print(name)
40     #del name[0]       #删除索引1的元素
41     del name[0:2]      #删除指定索引的元素
42     print(name)
43 
44      
45     count    显示元素aa出现个数    
46 
47     name = ["1","aa","cc","aa","33","22"]
48     print(name.count("aa"))
49 
50      
51     显示元素的位置,没有就报错    index
52 
53     name = ["1","aa","cc","bb","33","22"]
54     print(name.index("cc"))
55 
56      
57     排序 从小到大    sort
58 
59     name = ["1","aa","cc","bb","33","22"]
60     name.sort()
61     print(name)
62 
63      
64     反转排序    reverse
65 
66     name = ["1","aa","cc","bb","33","22"]
67 
68     name.reverse()
69 
70     print(name)
71 
72     更新             a=[\'A\',\'B\'] a[1] = \'JavaScript 代码片段
 片段内带有基本适配器的列表视图
 golang数据类型和各类型转换注意细节图文+代码
 如何为 apollo 客户端生成片段类型？
 c_cpp Robolution基本代码片段
 在代码片段中包含类型转换