python基础之数据类型及内置方法

一、数字类型

1.整型int:用来记录年龄、等级、号码等

int()可以接收数字和纯数字组成的字符串参数,不能接收浮点数的字符串.

当参数为浮点数时,函数会返回参数的整数部分.当参数是整数字符串时,函数将其转换为整型

定义一个整型变量：
a=27

 

2.浮点型float：用来记录身高、体重、工资等

定义一个浮点型变量：
price=11.22

 

进制转换：

十进制  ——>二进制  bin(27)   [反向为int("0b11011",2)]

十进制  ——>八进制 och(27)   [反向为int("0o33",8)]

十进制  ——>十六进制  hex(27)  [反向为int("0x1b",16)]

      

二、字符串str：用来记录描述性质状态，如名字、性别等 

用引号（'',"",''''''）将内容包含起来赋给变量名，就可以定义一个字符串变量。

只有在全部数据为字符串时，用eval

使用引号将内容包含起来赋给变量名，就可以定义一个字符串变量。定义这两个变量时，实际调用了 str() 函数。
name ='lalal'

当字符串内有引号时，定义的引号需要不能和其相同：

str3 = "hello,I'm lily."

字符串类型可以用运算符进行简单的拼接：
str1 = "hello  "
str2 = "world! "
res = str1+str2

print(res)          #hello  world!
print(res*3)       #hello  world! hello  world! hello  world!

字符串类型之间也可以比较大小：

str1 = "hello  "
str2 = "world! "

print(str1>str2)    #False,根据ASCII码得来. A<Z<a<z

字符串类型并不能和其他数据类型进行拼接和运算

 

需要即时掌握的操作
1.strl[0] 按索引取值 
2.strl[1:3:2] 切片(顾头不顾尾，步长）
3.len 长度(统计的是字符个数)
4.in/not in 成员运算 (返回布尔值)
5.strip,lstrip,rstrip 移除空白 
6.split，rsplit 切分.切出来的是列表
7.for i in listl 循环遍历

str1 = "lalal,27,hello world!"
list1 = [
    # str1[0:9:3],  # la2 间隔两个字符切片(步长指定为2,默认为1)
    # str1[:],  # lalal,27,hello world!  起始位置和结束位置默认为0,可以获得一个同样的字符串
    # str1[::-1],  # !dlrow olleh,72,lalal  返回一个倒序字符串
    # str1[-3:],  # ld!  返回后三个字符
    # str1[-1:-5:-1],  # !dlr  起始位置都可以是负值,但切片的方向要和步长一致
    # len(str1),  # 21  返回str1的长度(字符个数),如果len()的参数是列表、元组,则返回元素个数
    # "12" in str1,  # False 成员运算,返回布尔值
    # str1.strip(),  # lalal,27,hello world! 移除str1两端的指定字符,默认为空格 返回一个新的字符串
    # str1.split(",", 2),  # ['lalal', '27', 'hello world!']  此函数接收两个参数:切分字符和个数,返回一个列表
    "0".join(str1.split(",", 2))  # lalal0270hello world! 将切分后的列表元素以指定的字符拼接,原理是字符串拼接+迭代
#
]
for i in list1:
    print(i)

 

需要优先掌握的操作
1.lower 将str1内的英文字符转换为大写
2.upper 将str1内的英文字符转换为小写
3.startswith 判断str1是否以"xx"开头,并返回布尔值
4.endswith 判断str1是否以"xx"结尾
5.fomat 格式化输出三种用法（与%：%需要一一对应，相当于第一种用法，数目不匹配报错。）
6.replace 替换
7.join 拼接，相当于for循环，可迭代的对象必须都是字符串
8.isdigit 判断字符是否为"数字"，可以判断bytes和unicode类型
9.isinstance 判断...是否是...类型

str1 = "lalal,27,hello world!  "
list1 = [
    str1.lower(),  # lalal,27,hello world!  将str1内的英文字符转换为小写并返回一个新字符串
    str1.upper(),  # LALAL,27,HELLO WORLD!  将str1内的英文字符转换为大写并返回一个新字符串
    str1.startswith("12"),  # False  判断str1是否以"12"开头,并返回布尔值
    str1.endswith("!"),     # False  判断str1是否以"!"结尾,并返回布尔值
    "la{},27,hel{}lo world!  ".format("3", "T"),  # la3,27,helTlo world!  格式化输出:按顺序输出
    "la{1},27,he{0}world!    ".format("3", "T"),  # laT,27,he3world!  格式化输出:指定位置
    "la{x},27,he{y}world!    ".format(x="3", y="T"),  # la3,27,heTworld  格式化输出:指定关键字!
    str1.replace("27", "dz", 1),  # lalal,27,hello world!   replace接收三个参数:原字符,替换字符,替换字数
    str1.isdigit(),  # False 判断str1是否是纯数字字符,返回布尔值
]
for i in list1:
    print(i)

 

需要了解的方法
1.count
2.find,rfind
3.index,rindex
4.center,ljust,rjust,zfill 居中，左，右，
5.captalize 首字母大写
6.swapcase
7.title 全大写

str1 = "LalAl,27,heLlo World!    "
list1 = [
    str1.count("l"),  # 4   返回srt1内指定字符的个数,不指定字符则统计整个字符串的字符数  
    str1.find("27"),  # 6  返回指定字符在str1中的索引,如果不存在则返回-1。  rfind()从右向左寻找  
    str1.index("La"), # 0  返回指定字符在str1中的索引,如果不存在则报错。 rindex()从右向左寻找
    str1.center(30, "_"), # __LalAl,27,heLlo World!    ___
    # 返回一个原字符串居中,并使用指定单位字符
    # 填充至指定长度的新字符串。默认填充字符为一个空格。
    # 如果指定的长度小于原字符串的长度则返回原字符串。
    # 类似调整格式的方法还有 左对齐:ljust()  右对齐:rjust()  用0填充:zfill()
    str1.capitalize(),  # Lalal,27,hello world!首字母大写
    str1.swapcase(),  # Lalal,27,hello world!大小写互换
    str1.title()  # Lalal,27,Hello World!  返回英文单词首字母大写的字符串
]
for i in list1:
    print(i)

 

 

is数字
1.isdigt:判断bytes,unicode类型
2.isdecimal:uncicode
3.isnumberic:unicode,中文数字,罗马数字
4.isalnum
5.isalpha
6.isidentifier
7.islower,isupper
8.isspace
9.istitle

#is数字系列
#在python3中
num1='4'     #bytes
num2=u'4'    # unicode,python3中无需加u就是unicode
num3='四'    # 中文数字
num4='Ⅳ'    # 罗马数字
print(num1,num2,num3,num4)    # 4 4 四 Ⅳ

#isdigt:bytes,unicode
print(num1.isdigit())       # True
print(num2.isdigit())       # True
print(num3.isdigit())       # False
print(num4.isdigit())       # False

#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal())     # True
print(num3.isdecimal())     # False
print(num4.isdecimal())     # False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric())     # True
print(num3.isnumeric())     # True
print(num4.isnumeric())     # True

# 三者不能判断浮点数
num5='4.3'
print(num5.isdigit())       # False
print(num5.isdecimal())     # False
print(num5.isnumeric())     # False

'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景。
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

# is其他
print('===>')
name='egon123'
print(name.isalnum())      # True 字符串由字母或数字组成
print(name.isalpha())      # False 字符串只由字母组成
print(name.isidentifier()) # True
print(name.islower())      # True
print(name.isupper())      # False
print(name.isspace())      # False
print(name.istitle())      # False

 

字符串的一些方法,比如按按索引取值、成员运算、切片、返回长度(元素个数)等方法对于列表,字典等数据类型同样适用.

 

 三、列表list：用来记录多个值，用索引对应值，索引反映位置。在[]内以逗号分隔多个任意类型的值

list1=[1,2.1,'lalal',['a','b','c']]

print(type(list1))     #<class 'list'>
print(list1[0])         #1
print(list1[3][0])    #a

当索引超出列表的长度时，就会报错

 

需要优先掌握的操作
1.listl[0]     按索引取值 
2.listl[1:3:2] 切片(顾头不顾尾，步长）
3.len         长度(统计的是元素个数)
4.in/not in   成员运算 (返回布尔值)
5.append      追加(如果有一个列表，会将其当作一个元素整个追加）
6.insert      插入
7.del         删除（根据索引删）
8.remove      删除（单纯的根据元素名去删）
9.pop        删除（若不指定索引，默认取走最后一个，有返回值，为删掉的值）
10.for i in listl  遍历列表

l = ['a', 'b', 'c', 'd', 'e']

print(l[0], l[0:2:1])  # a ['a', 'b']  按索引取值、切片（返回子列表），与字符串切片方法相同
l[2] = "C"       # 替换索引位置元素
print(l,len(l))  # ['a', 'b', 'C', 'd', 'e'] 5   返回列表与元素个数（长度）
print("a" in l)  # True  in/not in成员运算
l.append("1")  # 列表末尾追加元素,无返回值
print(l)       #['a', 'b', 'c', 'd', 'e', '1']
l.insert(0, 11111)  # 在指定索引位置插入元素IKN
print(l)            #[11111, 'a', 'b', 'c', 'd', 'e']
del l[0]       # 删除
print(l)       #['a', 'b', 'c', 'd', 'e']
l.remove("b")     # 删除指定元素
print(l)          #['a', 'c', 'd', 'e']
l.pop(1)      # 删除指定索引位置元素，并将删除的元素返回。默认索引为-1
print(l)      #['a', 'd', 'e']
for item in l:    # 遍历列表
    print(item)   #a d e

 

 

需要掌握的操作
1.count       计数
2.extend      追加（如果有一个列表，会将其按元素逐个添加）
3.index       索引所在位置，可以指定起始范围，若没有该vaule，报错。
4.reverse     倒序
5.sort        排序（从小到大）可以跟匿名
6.join

l = ['a', 'b', 'c', 'd', 'e']

print(l.count("a"))  # 1  返回列表中包含指定元素的个数

l2 = ["!","!"]
l.extend(l2)
print(l)        #  ['a', 'b', 'c', 'd', 'e', '!', '!']  接收一个可迭代对象，将其元素添加到l中，返回None
print(l.extend(12))  # 报错

print(l.index('c'))  # 2  返回指定vaule的索引，可以指定起始范围，若没有该vaule，报错。
l.reverse()  # 反转列表
print(l)     #['e', 'd', 'c', 'b', 'a']
print(l.reverse())   # None

l.sort()  # 将列表中元素按从小到大顺序排序，若指定reverse=True，则倒序
print(l)  # ['a', 'b', 'c', 'd', 'e']

 

1.队列:先进先出
l=[]
l.append('first')
l.append('second')
l.append('third')
print(l)  #['first', 'second', 'third']
print(l.pop(0))  #first
print(l.pop(0))  #second

# 2.堆栈:先进后出
#
l=[]
l.append('1')
l.append('2')
l.append('3')
print(l)  #['1', '2', '3']
print(l.pop(-1))  #3
print(l.pop(-1))  #2

 

列表生成式 【i for i in range(10)】 --详情后文讲

 

四、字典dict：在{ }里，用key：vaule的形式存放多个元素，并用，将元素隔开.

字典的key一定是不可变类型(内部需要做hash)，因为key起到描述作用，一般是字符串型，vaule可以是任意类型。定义字典调用了 dict(）方法，dict() 接收可迭代对象（k, v in iterable）和关键字参数：

d = {'name1':'lalal','name2':'ann','name3':'sha'}

print(d["name1"])        #lalal

字典没有索引，即无序的。用花括号{ } 可以定义一个字典，字典的元素包含键（key）和值（vaule），中间用冒号 ：分开。冒号左边是key，一定要用不可变类型，比如字符串，我们可以通过key访问到vaule。

 

需要优先掌握的操作
1.dictl['key']   按key取值 
2.len            长度(统计的是元素个数)
3.in/not in      成员运算 (返回布尔值)
4.d.get('key')   按key取值
5.pop
6.del dictl[]    删除(指定key删除，无返回值)
7.键:key  值:values  键值对:items()
8.for i in dic.iteml() 

dict1 = {'name': 'lalal', 'age': 27, 'gender': 'male'}
print(dict1["name"])      #lalal   按key取值
print(dict1.get("age"))   # 27     按key取值,如果不存在这个key则返回None，不会报错

dict1["name"] = "dz"     # 当指定的key存在时，修改对应的vaule。如果不存在，则新增元素。
print(dict1['name'])     # dz

dict1.setdefault("age",20)       # 指定的key存在时，不修改对应的vaule；若不存在，则新增元素。返回值是key对应的vaule
print(dict1)                     #{'name': 'lalal', 'age': 27, 'gender': 'male'}
print(dict1.setdefault("age",20))  # 27

print(dict1.pop("name"))   # lalal  删除key所在的元素，并返回vaule，如果不存在会报错
print(dict1)        #{'age': 27, 'gender': 'male'}

print(dict1.popitem())    # ('gender', 'male')  随机删除一个元素，以元组的形式返回此元素
print(dict1)        #{'name': 'lalal', 'age': 27}

print(dict1.keys())    # 输出键  dict_keys(['name', 'age', 'gender'])  
print(dict1.values())  # 输出值  dict_values(['lalal', 27, 'male'])  
print(dict1.items())   # 输出键值对  dict_items([('name', 'lalal'), ('age', 27), ('gender', 'male')])  

以上三个输出的返回值是可迭代对象，可以用for 遍历出元素

for k in dict1.keys():
    print(k)    # name age gender
for v in dict1.values():
    print(v)     # lalal  27  male

for k, v in dict1.items():
    print(k, v)
# name lalal
# age 27
# gender male

 

需要掌握的操作
1.fromkeys     初始化一个字典
2.update       更新字典
3.setdefault 

dict1 = {'name', 'age', 'gender'}
d={}.fromkeys(dict1,None)      # 初始化一个vaule为None的字典
print(d)                    #{'name': None, 'age': None, 'gender': None}

dic1 = {'name': 'lalal', 'age': 27, 'gender': 'male'}
d.update(dic1)   # 更新字典，更新原有key对应的vaule，并增加原来没有的元素
print(d)         #{'gender': 'male', 'name': 'lalal', 'age': 27}

 

 存多值、无序、可变

 

五、布尔bool：描述两种状态，True、False (注意大小写).

if 3>2:
    print(3>2)                   #  True        
    print(type(3>2))          #<class 'bool'>

所有的数据类型自带bool值

布尔值为False：0，None，空（比如空字符串""，空列表[]）

 

 所有的数据类型自带bool值，需要注意：

0，None，空（比如空字符串""，空列表[]）的布尔值为False

 

六、元组tuple：相当于一个不可变列表，形式上是在（）内用，将多个任意类型的元素隔开定义一个元组调用了tuple() 函数，tuple()函数接收一个可迭代对象，将其转换为元组的元素。 

元组可视为不可修改的列表。修改元组内元素会报错，但是:
t=(1,"1",[1,2,3])  # 定义一个元组
t[2][0] = "hello"
print(t)                #(1, '1', ['hello', 2, 3])
元组里的内容的确修改了，实际上，元组内存储的是vaule的地址，修改列表内的元素并不会改变地址
 

 

需要优先掌握的操作
1.tuplel[0]     按索引取值 
2.tuplel[1:3:2]  切片(顾头不顾尾，步长）
3.len           长度(统计的是元素个数)
4.in/not in     成员运算 (返回布尔值)
5.for i in tuplel

t = ['a', 'b', 'c', 'd', 'e']

print(t[0], t[0:2:1])  # a   ['a', 'b']按索引取值、切片（返回子列表），与字符串切片方法相同
t[2] = "C"       # 替换索引位置元素
print(t,len(t))  # ['a', 'b', 'C', 'd', 'e'] 5   返回列表与元素个数（长度）
print("a" in t)  # True  in/not in成员运算
for item in t:    # 遍历列表
    print(item)   #a b C d e

 

需要掌握的操作
1.count       计数
2.index       索引所在位置，可以指定起始范围

t = ['a', 'b', 'c', 'd', 'e']
print(t.index('d',1,5))  # 3  找到索引d在元组（范围1~5）中所在的位置，
print(t.count('a'))      #1  计a的个数

 

存多值、有序、不可变

 

七、集合set：用{ }的形式表示，内部元素用 ， 分隔

集合的主要用途：I关系运算  II去重（局限性：1.只针对不可变类型 2.不能保证原来顺序，可用set.index）

集合是无序的，其中的元素必须是不可变类型，并且没有重复元素。定义集合会调用 set() 函数，该函数会生成一个集合，去除重复元素。

set1 = set([1, 'a', 'b'])
set2 = set("hello")
print(set1, set2)   #{1, 'a', 'b'} {'e', 'o', 'h', 'l'}

 

  

需要优先掌握的操作
1.len           长度(统计的是元素个数)
2.in/not in     成员运算 (返回布尔值)
3.| 合集
4.& 交集
5.- 差集
6.^ 对称差集
7.==
8.>=父集
9.<=子集

s1 = {"张","王","李","赵"}
s2 = {"赵","钱","孙","李"}

print(s1|s2)    # 并集  {'王', '李', '赵', '钱', '张', '孙'}
print(s1&s2)    # 交集  {'李', '赵'}
print(s1-s2)    # 差集  {'王', '张'}
print(s2-s1)    #{'钱', '孙'}
print(s1^s2)    # {'王', '钱', '张', '孙'} 对称差集：没有同时存在与s1和s2的元素

print(s1==s2)   # False   判断两集合是否相等
print(s2>=s1)   # False   判断s2是否包含s1（s2是否为s1的父集）（s1是否为s2的子集）
print(s2<=s1)   # False   

 

需要掌握的操作
1.update
2.pop
3.remove
4.discard

s1 = {"张","王","李","赵"}

print(len(s1))      #4
print(s1.pop())     #李

s1.add("刘")          # 添加元素，无返回值。
print(s1)             #{'王', '刘', '张', '李', '赵'}
s1.update('钱')     # 更新集合，无返回值
print(s1)           #{'李', '钱', '赵', '王', '张'

s1.remove('王')     #移除，无返回值。删除集合中没有的元素时会报错
print(s1)           #{'李', '张', '赵'}
s1.discard('张')      #移除，无返回值。删除集合中没有的元素时不会报错
print(s1)             #{'李', '赵', '王'}

 

存多值、无序、可变

 

八、None：代表没有任何东西，它甚至没有任何类型

None的定义用法

print(type(None))       # <class 'NoneType'>

 

类型小结

1）按存值个数分
存单个（标量／原子类型）:字符串
存多个（容器类型）:列表、元组、字典（、集合）

2）按可变不可变分
可变:列表、字典、可变集合
不可变:数字、字符串、元组、不可变集合

（set —— 可变集合。集合中的元素可以动态的增加或删除。frozenset —— 不可变集合。集合中的元素不可改变。）

3）按访问顺序分
直接取:数字
索引取:字符串、列表、元组
key取: 字典

4）按有无序分
有序:列表、元组、字符串
无序:字典、集合

5）按存储空间的占用分（从低到高）

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改