python3的数据类型及内置方法

1.数字类型int与float
1.1定义

age=10  #本质age=int(10)
salary=20.3  #本质salary=float（20.3）

1.2类型转换

十进制转二进制
>>> bin(3)
'0b11'
十进制转八进制
>>> oct(9)
'0o11'
十进制转十六进制
>>> hex(17)
'0x11'
二进制转十进制
>>> int('0b11',2)
3
八进制转十进制
>>> int('0o11',8)
9
十六进制转十进制
>>> int('0x11',16)
17

2.字符串
2.1定义
定义：在单引号\双引号\三引号内包含一串字符

name1 = 'jason'  # 本质:name = str('任意形式内容')
name2 = "lili"  # 本质:name = str("任意形式内容")
name3 = """ricky"""  # 本质:name = str("""任意形式内容""")

2.2类型转换
数据类型转换：str()可以将任意数据类型转换成字符串类型，例如

>>> type(str([1,2,3])) # list->str
<class 'str'>
>>> type(str({"name":"jason","age":18})) # dict->str
<class 'str'>
>>> type(str((1,2,3)))  # tuple->str
<class 'str'>
>>> type(str({1,2,3,4})) # set->str
<class 'str'>

3.3使用

str1 = 'hello world'
按索引取值（正向取，反向取）
print(str1[2])  # l
print(str1[-1])  # d
注意：对于str来说，只能取，不能改

切片（顾头不顾尾，步长）
print(str1[0:3])  # hel
print(str1[::2])  # hlowrd
print(str1[-1::-2])  # drwolh

长度len
获取字符串长度，即字符的个数，但凡在引号内的都算作字符
print(len(str1))  # 11

成员运算 in 和 not in
print('hell' in str1)#True
print('hell' not in str1)#False

strip移除字符串首尾指定的字符（默认移除空格）
strip:移除两边
lstrip:移除左边
rstrip:移除右边


str2='    life is short!   '
print(str2.strip()) #life is short!

str3='******life is short!*********'
print(str3.strip('*')) #life is short!

切片split
注意:split切割得到的结果是列表数据类型
括号内不指定字符默认以空格作为切分符号
print(str1.split())# ['hello', 'world']
括号内指定分隔符，则按照括号内指定的字符切割字符串
str4='127.0.0.1'
print(str4.split('.'))#['127', '0', '0', '1']
split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
str5='C:/a/b/c/d.txt'
str5.split('/',1)#['C:', 'a/b/c/d.txt']

rsplit刚好与split相反，从右往左切割，可以指定切割次数
str5='a|b|c'
str5.rsplit('|',1)#['a|b', 'c']

lower(),upper()
lower():全部小写
upper():全部大写

startswith,endswith
startswith():判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
endswith():判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False

join
从可迭代对象中取出多个---字符串---，然后按照指定的分隔符进行拼接，拼接的结果为字符串
# print('%'.join('hello')) #h%e%l%l%o
# print('|'.join(['zhaowei','18','read']))#zhaowei|18|read

#replace
#用新的字符替换字符串中旧的字符
# str6='my name is zhaowei,my age is 18!' #将年龄修改为73
# print(str6.replace('18','73')) #语法：replace('旧内容','新内容')
#可以指定修改的个数
# print(str6.replace('my','My')) #默认修改全部 My name is zhaowei,My age is 18!
# print(str6.replace('my','My',1))#只修改一个 My name is zhaowei,my age is 18!

# isdigit
# 判断字符串是够是纯数字组成，返回结果为True或False
# str7='5201314'
# print(str7.isdigit())#True
# str8='520you1314'
# print(str8.isdigit())#False

# find
# 从指定范围内查找子字符串的起始索引，找到则返回数字，找不到则返回-1
# msg='tony say hello'
# print(msg.find('o',1,3))#1
# print(msg.find('o'))#1

# index
# 同find，但是找不到时会报错
#print(msg.index('e',2,4))
# Traceback (most recent call last):
#   File "<pyshell#79>", line 1, in <module>
#     print(msg.index('e',2,4))
# ValueError: substring not found

# count：统计字符串在大字符串中出现的次数
# msg='hello everyone'
# print(msg.count('e'))#4
# print(msg.count('e',1,6))#1

# center,ljust,rjust
# name='tony'
# print(name.center(30,'*'))#*************tony*************
# print(name.ljust(30,'*'))#tony**************************
# print(name.rjust(30,'*'))#**************************tony
#zfill
# 只能用‘0’填充,字符串右对齐
# print(name.zfill(30))#00000000000000000000000000tony

# expandtabs
# name='tony\thello' #\t表示制表符（tab）
# print(name)#tony hello
# print(name.expandtabs(2))#tony  hello

# captalize
# 首字母大写
# message='hello everyone nice to meet you'
# print(message.capitalize())#Hello everyone nice to meet you

#swapcase
#大小写翻转
# message='Hi girl,I want make friends with you'
# print(message.swapcase())#hI GIRL,i WANT MAKE FRIENDS WITH YOU

# title
#每个单词首字母大写
# msg='dear my friend i miss you every much'
# print(msg.title())#Dear My Friend I Miss You Every Much

# 3列表
# 定义：在[]内,用逗号分隔开多个任意数据类型的值
# l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])
#可以for循环遍历的都可以进行转换

# 按索引取值（正向取+反向取）：即可存也可取
# 正向取
my_friends=['tony','jason','tom',4,5]
# print(my_friends[1])#jason
# 反向取（-号表示从右往左取）
# print(my_friends[-1])#5

# 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在就会报错
# my_friends[0]='zhaowei'
# print(my_friends)

# 切片（顾头不顾尾，步长）
# print(my_friends[::2])#['tony', 'tom', 5]
# print(my_friends[0:4])#['tony', 'jason', 'tom', 4]

# 长度
# print(len(my_friends))#5

# 成员运算（in和not in）  
# print('tony' in my_friends)#True
# print('xxx' not in my_friends)#True
#
# 添加
# append()列表尾部追加元素
# list1 = ['a', 'b', 'c']
# list1.append('d')
# print(list1) #['a', 'b', 'c', 'd']
#
# extend()一次性在尾部添加多个元素
# list1.extend(['a','b','c','d'])#['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']
# print(list1)
#
# insert()在指定位置插入元素
# list1.insert(0,'first')  #'0'表示按索引位置插值
# print(list1) #['first', 'a', 'b', 'c']
#
# 删除
# del
# list2 = [11, 22, 33, 44, 55]
# del list2[0]
# print(list2) #[22, 33, 44, 55]
#
# pop（）：默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
# res=list2.pop()
# print(res) #55
# res=list2.pop(1)
# print(res) #22
#
# remove():括号内表明要删除的元素，没有返回值
# res=list2.remove(22) #从左往右查找第一个括号内需要删除的元素
# print(res)#None
#
# reverse():颠倒列表内元素的顺序
# list2.reverse()
# print(list2)#[55, 44, 33, 22, 11]
#
# sort():给列表内所有元素排序
# 排序时列表元素之间必须数据类型相同，不可以混搭，否则报错
# list3=[3,4,2,4,2,46,3,34,35,345,9]
# list3.sort()
# print(list3)#[2, 2, 3, 3, 4, 4, 9, 34, 35, 46, 345]
# 可以指定是否颠倒排序，默认为false
# list3.sort(reverse=True)
# print(list3)#[345, 46, 35, 34, 9, 4, 4, 3, 3, 2, 2]
#
# 4.元组
# 元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取
# 定义方式：在括号内用逗号分隔开多个任意类型得到值
# countries = ("中国", "美国", "英国")  # 本质:countries = tuple("中国"，"美国"，"英国")
# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
# countries = ("中国",)  # 本质:countries = tuple("中国")
#
# 类型转换
# 只要是能被for循环遍历的数据类型都可以传给tuple（）转换成元组类型
# tuple('wdad') # 结果：('w', 'd', 'a', 'd')
# tuple([1,2,3]) # 结果：(1, 2, 3)
# tuple({"name":"jason","age":18}) # 结果：('name', 'age')
# tuple((1,2,3)) # 结果：(1, 2, 3)
# tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中
#
# 使用
# tuple1=(1,'hahaha',23423432,45.3)#23423432
# 按索引取值（正向取+反向取），只能取不能改，否则报错
# print(tuple1[2])
#
# 2、切片(顾头不顾尾，步长)
# >>> tuple1[0:6:2]
# (1, 15000.0, 22)
#
# 3、长度
# >>> len(tuple1)
# 6
#
# 4、成员运算 in 和 not in
# >>> 'hhaha' in tuple1
# True
# >>> 'hhaha' not in tuple1
# False
#
# 5、循环
# >>> for line in tuple1:
# ...     print(line)
# 1
# hhaha
# 15000.0
# 11
# 22
# 33
#
# 5.字典
# 定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能
# info = {'name': 'zhaowei', 'age': 18, 'sex': 'male'}
# 或者
# info = dict(name='tony', age=18, sex='male')
#
# 类型转换
# info=dict([['name','tony'],('age',18)])
# print(info)#{'name': 'tony', 'age': 18}
# 或
# fromkeys会从元组中取出每个值当做key，然后与none组成key：value放到字典中
# dict1={}.fromkeys(('name','age','sex'),None)
# print(dict1)#{'name': None, 'age': None, 'sex': None}
#
# 使用
# 按key存取值：可存可取
# dict2 = {
#     'name': 'zhaowei',
#     'age': 18,
#     'hobbies': ['play game', 'basketball']
# }
# print(dict2['name'])#zhaowei
#
# 对于赋值操作，如果key原先不存在于字典，则会新增key:value
# dict2['gender']='male'
# print(dict2)#{'name': 'zhaowei', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}
#
# 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
# dict2['age']=20
# print(dict2['age'])#20
#
# 3、成员运算in和not in
# >>> 'name' in dic  # 判断某个值是否是字典的key
# True
#
# 键keys(),值values(),键值对items()
# print(dict2.keys())  # 获取字典所有的key #dict_keys(['name', 'age', 'hobbies'])
# print(dict2.values())  # 获取字典所有的value#dict_values(['zhaowei', 18, ['play game', 'basketball']])
# print(dict2.items())  # 获取字典所有的键值对#dict_items([('name', 'zhaowei'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
#
# 循环
# 默认遍历的是字典的key
# for i in dict2:
# #     print(i)#name  age     hobbies
#
# # 只遍历key
# for key in dict2.keys():
#     print(key)
#
# 只遍历value
# for value in dict2.values():
#     print(value)
#
# 遍历key和value
# for k,v in dict2.items():
#     print(k,v)#name zhaowei
#
# get():通过key获取value
# dict3={'k1':'jason','k2':'tony','k3':'JY'}
# print(dict3.get('k1'))#jason
# print(dict3.get('k4'))#None  如果key不存在就返回None
# print(dict3.get('k4','zhaowei'))#zhaowei   key不存在时，可以设置默认返回值
# 建议：字典取值建议用get方法
#
# pop():删除指定key对应的value的键值对，并返回值
# dict3 = {'k1': 'jason', 'k2': 'tony', 'k3': 'JY'}
# print(dict3.pop('k1'))#jason
#
# popitem():随机删除一组键值对，并将删除的键值对放到元组内并返回
# item=dict3.popitem()
# print(item)#('k3', 'JY')
#
# upate():用新字典更新旧字典，有则修改，无则添加
# dict3.update({'k1':'lala','k4':'huahua'})
# print(dict3)#{'k1': 'lala', 'k2': 'tony', 'k3': 'JY', 'k4': 'huahua'}
#
# fromkeys():用于创建字典
# dict4=dict.fromkeys(['k1','k2','k3'])
# print(dict4)#{'k1': None, 'k2': None, 'k3': None}
# dict4=dict.fromkeys(['k1','k2','k3'],[])
# print(dict4)#{'k1': [], 'k2': [], 'k3': []}
#
# setdefault()
# dict5 = {'k1': 111, 'k2': 222}
# print(dict5.setdefault('k3', 333))  # 333  key不存在则新增键值对，并将新增的value返回
# print(dict5.setdefault('k1', 444))  # 111  key存在则不做任何修改，并返回已存在key对应的value值
#
# 6集合
# 集合，list.tuple,dict一样都可以存放多个值，但是集合主要用于去重，关系运算
# 定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点
#       1.每个元素必须是不可变类型
#         2.集合内没有重复的元素
#         3.集合内元素无序
#
# s = {1, 2, 3, 4}  # 本质 s = set({1,2,3,4})
# 注意：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key对应值，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系运算，根本没有取出单个指定值的需求
# d = {}  # 这是空字典
# s = set()  # 这是定义空集合
#
# # 类型转换
# 但凡能够被for循环遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
# >>> s = set([1,2,3,4])
# >>> s1 = set((1,2,3,4))
# >>> s2 = set({'name':'jason',})
# >>> s3 = set('egon')
# >>> s,s1,s2,s3
# {1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
#
# 使用
# friends1 = {'zero', 'kevin', 'jason', 'egon'}
# friends2 = {'Jy', 'ricky', 'jason', 'egon'}
# 合集（并集）：求两个用户的所有好友（重复好友只有一个）
# print(friends1|friends2)#{'kevin', 'jason', 'ricky', 'egon', 'zero', 'Jy'}
#
# 交集：求两个用户的共同好友
# print(friends1 & friends2)#{'egon', 'jason'}
#
# 差集
# print(friends1 - friends2)#{'kevin', 'zero'}  求用户1独有的好友
# print(friends2 - friends1)#{'ricky', 'Jy'}   求用户2独有的好友
#
# 对称差集(^) 求两个用户独有的好友们（即去掉共同的好友）
# print(friends1 ^ friends2) #{'Jy', 'kevin', 'zero', 'ricky'}
#
# 值是否相等（==）
# print(friends1 == friends2) #False
#
# 父子集：一个集合是否包含另一个集合
# 6.1 包含则返回True
# >>> {1,2,3} > {1,2}
# True
# >>> {1,2,3} >= {1,2}
# True
# # 6.2 不存在包含关系，则返回False
# >>> {1,2,3} > {1,3,4,5}
# False
# >>> {1,2,3} >= {1,3,4,5}
# False
#
# >>> {1,2} < {1,2,3}
# True
# >>> {1,2} <= {1,2,3}
# True
#
# 去重
# 只能针对不可变类型
# 集合是无序的，去重之后无法保留原来的顺序
# 集合是不合重复的
#
# >>> l=['a','b',1,'a','a']
# >>> s=set(l)
# >>> s # 将列表转成了集合
# {'b', 'a', 1}
# >>> l_new=list(s) # 再将集合转回列表
# >>> l_new
# ['b', 'a', 1] # 去除了重复，但是打乱了顺序
#
# # 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
# l=[
#     {'name':'lili','age':18,'sex':'male'},
#     {'name':'jack','age':73,'sex':'male'},
#     {'name':'tom','age':20,'sex':'female'},
#     {'name':'lili','age':18,'sex':'male'},
#     {'name':'lili','age':18,'sex':'male'},
# ]
#
# new_l=[]
#
# for dic in l:
#     if dic not in new_l:
#         new_l.append(dic)
#
# print(new_l)
# # 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
# [
#     {'age': 18, 'sex': 'male', 'name': 'lili'},
#     {'age': 73, 'sex': 'male', 'name': 'jack'},
#     {'age': 20, 'sex': 'female', 'name': 'tom'}
#
# 7，可变类型与不可变类型
# 可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值
# 不可变数据类型：值发生改变，内存地址也发生改变，即id也变，证明没有改变原值，是产生了新的值
# 不可变类型：数字（int,float),字符串，元组，
# 可变类型：列表，字典