基本数据类型及内置方法
一、数字类型int与float
- int整形的定义：
age=10 #本质age = int(10)
其他进制转十进制
二进制：0,1 （如110）
1 * (2** 2)+1 * (2** 1) + 0 * (2** 0) = 4+2+0 = 6
八进制：0-7 （如123）
1 * (8** 2) + 2 * (8** 1) + 3 * (8**0) = 64 + 16 + 3 = 83
十六进制：0-9 a-f
3 * (16 ** 2) + 2 * (16 ** 1) + 1 * (16** 0) = 768 + 32 + 1 = 801
十进制转其他进制
#十进制转二进制： # print(bin(108)) # 0b 1101100 #十进制转八进制： # print(oct(83)) # 0o 123 #十进制转十六进制： # print(hex(1000)) # 0x 3e8
float浮点型的定义
height = 1.73 #本质height=float(1.73)字符串转整形需要先转成浮点型
二、字符串str
字符串的定义：单引号/双引号/三引号之间包含的字符就是字符串（三种方式没有任何区别，但是不可以混用）
字符串前面加小写的r，代表转义（如果字符串中有特殊含义的字符，就可以定义为普通字符）
#数据类型转换：str()可以将任意数据类型转换成字符串类型，如： l1 = [1,2,3,4,5] print(type(l1)) print(type(str(l1))) <class 'list'> <class 'str'>
1.索引取值：（正向取，反向取） 只能取值不能存
s1 = 'hello world'
>>> s1[4] #表示正向取值，从左往右 'o' >>> s1[-7] #表示反向取值，从右往左 'o'
2.索引切片：截取字符串中的一小段字符串（顾头不顾尾）
>>> s1[0:5] #取出索引为0-4的所有字符 'hello' >>> s1[5:] #取出索引从5开始后面所有的字符 ' world' >>> s1[::-1] #从右往左依次取值 'dlrow olleh' >>>
3.长度len：获取字符串的长度，也就是字符的个数，空格也算字符
>>> len(s1) 11
4.成员运算：in 和 not in
>>> 'hello' in s1 #判断hello在不在s1中 True >>> 'world' not in s1 #判断world是否不在s1中 False
5.strip：移除字符串首尾指定的字符，默认移除空格
>>> s2 = '**hello**'
>>> s2.strip('*') #括号中指定移除的字符，如果不输入，默认移除空格
'hello'
lstrip移除左边的字符
>>> s2 = '***hello***'
>>> s2.lstrip('*')
'hello***'
rstrip 移除右边的字符
>>> s2.rstrip('*')
'***hello'
6.split切分：对字符串进行切分，可以指定切分的分隔符，也可以指定切分次数，返回的是列表
>>> s1.split() #默认空格作为切分符号
['hello', 'world']
>>> s2 = '192.168.1.111'
>>> s2.split('.') #指定以.作为切分符号
['192', '168', '1', '111']
>>> s2.split('.',1) #括号中的1代表切割的次数
['192', '168.1.111']
rsplit：可以从右往左切割
>>> s2.rsplit('.',1) #从右往左切分
['192.168.1', '111']
7.循环：依次取出字符串中的每个字符
s2 = '早上好'
for i in s2:
print(i)
早
上
好
8.lower(),upper()
>>> s3 = 'Hello World' >>> s3.lower() #将字母都变小写 'hello world' >>> s3.upper() #将字母都变大写 'HELLO WORLD'
9.startswith和endswith
>>> s1.startswith('h') #判断字符串开头是否是以括号里的字符开头
True
>>> s1.endswith('d') #判断字符串结尾是否是以括号里的字符结尾
True
>>> s1.startswith('d')
False
>>> s1.endswith('h')
False
10.格式化输出之forma
按位置一一对应
>>> name = 'yang'
>>> age = 22
>>> gender = 'male'
>>> print('my name is {},my age is {} and my gender is {}' .format(name, age, gender))
my name is yang,my age is 22 and my gender is male
按索引
>>> print('my name is {0},my age is {1} and my gender is {2}' .format(name, age, gender))
my name is yang,my age is 22 and my gender is male
>>> print('my name is {2},my age is {0} and my gender is {1}' .format(name, age, gender))
my name is male,my age is yang and my gender is 22
按指定参数传值
>>> print('my name is {a},my age is {b} and my gender is {c}' .format(a=name, b=age, c=gender))
my name is yang,my age is 22 and my gender is male
>>> print('my name is {c},my age is {a} and my gender is {b}' .format(a=name, b=age, c=gender))
my name is male,my age is yang and my gender is 22
11.join：将列表中每个元素按照字符串中的分隔符进行拼接
>>> L1 = ['yang','22','male'] >>> '|'.join(L1) 'yang|22|male' >>> '*'.join(L1) 'yang*22*male'
12.replace：将字符串中元素进行替换，（先旧后新）
>>> l1 = 'my name is yang, my age is 18'
>>> l1.replace('my', 'My') #语法：.replace('旧'，'新')
'My name is yang, My age is 18'
>>> l1.replace('my', 'My',1) #1 代表只把一个my改为 My
'My name is yang, my age is 18'
13.isdigit:判断字符串中的数据，是否是数字组成
>>> l2 = '31415926' >>> l2.isdigit() True >>> l2 = '3.1415926' >>> l2.isdigit() False
score = input('请输入您要查询的成绩:')
if score.isdigit():
score = int(score)
if score >= 60:
print('及格')
else:
print('不及格')
else:
print('请输入数字')
三、列表list
- 列表list的定义：在中括号[ ]内，用逗号分隔开的多个任意数据类型的值
>>> list('hello') #任意类型转换成list后，会把每个元素放到列表中
['h', 'e', 'l', 'l', 'o']
>>> list((1,2,3))
[1, 2, 3]
1.索引取值：正反都可以取，不仅可以取还可以存
>>> list1 = [1,2,3,4,5] >>> list1[0] #正向取索引从0开始 1 >>> list1[-1] #反向取表示从右往左 5
>>> list1[-1] = 6 #可以按照索引来修改制定位置的值 >>> list1 [1, 2, 3, 4, 6]
2.索引切片：顾头不顾尾
>>> list1[0:3] #按照索引取出0到3的元素 [1, 2, 3] >>> list1[0:5:2] #2代表步长，一次走两个元素 [1, 3, 6]
3.添加append：列表尾部追加元素
>>> list1.append(7) >>> list1 [1, 2, 3, 4, 6, 7]
4.extend：追加多个元素
>>> list1.extend([8,9,10]) >>> list1 [1, 2, 3, 4, 6, 7, 8, 9, 10]
5.insert：在指定位置插入元素
>>> list1.insert(4,5) >>> list1 #5就回来了 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
6.删除：
del
>>> del list1[-1] #删除索引为-1的元素 >>> list1 [1, 2, 3, 4, 5, 6, 7, 8, 9]
pop()：默认删除最后一个值，并且将删除的值返回，括号内也可以用索引来删除指定元素
>>> list1.pop() 9 #将删除的元素返回 >>> list1 [1, 2, 3, 4, 5, 6, 7, 8] >>> list1.pop(-1) #删除索引为-1的元素 8
remove() ：括号内表示要删除哪个元素，不需要用索引，没有返回值
>>> list1.remove(5) #咱们的5又没有了 >>> list1 [1, 2, 3, 4, 6, 7] >>> shanchu = list1.remove(4) #不会返回删除值 >>> print(shanchu) None
7.reverse()：颠倒顺序
>>> list1.reverse() >>> list1 [7, 6, 3, 2, 1]
8.sort()：给列表内所有元素排序
>>> list1 [7, 6, 3, 2, 1] >>> list1.sort() >>> list1 [1, 2, 3, 6, 7] #默认从小到大的顺序 >>> list1.sort(reverse=True) #reverse指定是否颠倒顺序，默认为False >>> list1 [7, 6, 3, 2, 1]
9.count:统计当前列表内指定元素的个数
>>> list.count(1) 2
10.index:获取当前指定元素的索引值，还可以指定查找范围
>>> list.index(8) 0 >>> list.index(7) 1
四、元组tuple
用途：存储多个不同类型的值（不能存可变类型）
定义方式：用小括号存储数据，数据之间通过逗号分隔
t1=('a','b') #t1=tuple(('a','b'))>>> t1 = (1,'hello',1.73,2,3)
1.索引取值：按索引取值（正取，反取），只能取，不能存
>>> t1[1] 'hello'
2.索引切片：（顾头不顾尾，步长）
>>> t1[0:5:2] (1, 1.73, 3)
3.成员运算：
>>> 'hello' in t1 True >>> 'world' in t1 False
4.长度len：
>>> len(t1) 5
5.循环：
>>> for i in t1: ... print(i) ... 1 hello 1.73 2 3
6.count
>>> t1.count(1)
1
>>> t1.count('hello')
1
7.index：
>>> t1.index(2) 3
五、字典dict
- 定义方式：通过大括号来存储数据，通过key：value来定义键值对数据，用逗号隔开
>>> info={'name':'yang','age':'22','sex':'male'}
>>> info
{'name': 'yang', 'age': '22', 'sex': 'male'}
- 类型转换
#第一种：
>>> info=dict([['name','yang'],('age','22')])
>>> info
{'name': 'yang', 'age': '22'}
#第二种：使用fromkeys生成一个新的字典，它会以第一个参数作为key，以第二个参数为值
>>> info.fromkeys(('name','age','sex'),None)
{'name': None, 'age': None, 'sex': None}
1.按照key存取值：
>>> info['name'] #使用key取值
'yang'
>>> info['age'] = '18' #如果字典中有key修改值
>>> info
{'name': 'yang', 'age': '18'}
>>> info['hobby'] = 'sleep' #如果字典里没有key，新增key：value
>>> info
{'name': 'yang', 'age': '18', 'hobby': 'sleep'}
2.长度：
>>> len(info) 3
3.成员运算：
>>> 'hobby' in info True >>> 'sex' in info False
4.get：获取指定key的值，若不存在，默认返回None
>>> info.get('age') #key存在则取值
'18'
>>> res = info.get('a') #key不存在返回None
>>> print(res)
None
>>> res = info.get('a',666) #第二个参数可以修改默认返回的值
>>> print(res)
666
keys：
>>> info.keys() #返回所有key dict_keys(['name', 'age', 'hobby']
values：
>>> info.values() #返回所有value dict_values(['yang', '18', 'sleep'])
items：
>>> info.items() #返回所有键值对，返回值都是列表套元组，每个键值对都是存在元组
dict_items([('name', 'yang'), ('age', '18'), ('hobby', 'sleep')])
5.pop()删除：指定key进行删除，有返回值，返回的是value
>>> info.pop('hobby')
'sleep'
>>> info
{'name': 'yang', 'age': '18'}
6.popitem()：随机弹出一个键值对，有返回值，返回一个元组
>>> info.popitem()
('age', '18')
>>> info
{'name': 'yang'}
7.update：用新字典替换旧字典，有则修改，无则添加
>>> info.update({'name':'chen'}) #有name则修改
>>> info
{'name': 'chen'}
>>> info.update({'age':'18'}) #无age则添加
>>> info
{'name': 'chen', 'age': '18'}
8.fromkeys：
>>> info.fromkeys(['name','age'],'oh')
{'name': 'oh', 'age': 'oh'}
#注意：不是同一个字典，而是生成新的一个字典，以第一个参数（列表）为key，第二个为value
>>> info
{'name': 'chen', 'age': '18'}
>>> info2 = info.fromkeys(['name','age'],'oh')
>>> info2
{'name': 'oh', 'age': 'oh'}
9.setdefault()：key不存在则新增键值对，存在返回对应的value
>>> info
{'name': 'chen', 'age': '18'}
>>> info.setdefault('hobby','buybuybuy') #key不存在旧新增
'buybuybuy' #返回对应value
>>> info
{'name': 'chen', 'age': '18', 'hobby': 'buybuybuy'}
>>> info.setdefault('age','22') #存在则返回已存在key对应的值
'18'
>>> info #对字典不做修改
{'name': 'chen', 'age': '18', 'hobby': 'buybuybuy'}
六、集合
- 用途：集合、列表、元组、字典都可以存放多个值，集合也一样，但是集合主要用于去重、关系运算
- 定义：用大括号存储，每个元素通过逗号隔开，定义空集合需用
set()来定义- 集合中每个元素必须是不可变类型
- 集合中没有重复的元素（体现了去重功能）
- 集合内元素无序
关系运算
1.合集（|）：求两个人的所有好友（重复的直留一个）
>>> friends1 = {'zero','sean','tank','egon'}
>>> friends2 = {'jj','elax','sean','egon'}
>>> friends1 | friends2
{'egon', 'zero', 'jj', 'elax', 'sean', 'tank'}
2.交集（&）：求两个人的共同好友
>>> friends1 & friends2
{'sean', 'egon'}
3.差集（-）：
>>> friends1 - friends2 #求1独有的好友
{'zero', 'tank'}
>>> friends2 - friends1 #求2独有的好友
{'elax', 'jj'}
4.对称差集（^）：求两个人的独有好友（就是去掉重复的之后）
>>> friends1 ^ friends2
{'zero', 'jj', 'elax', 'tank'}
5.值是否相等（==）：
>>> friends1 == friends2 False
6.父集：一个集合是否包含另外一个集合
>>> {1,2,3} > {1,2} #包含True
True
>>> {1,2,3} > {1,2,3,4} #不包含False
False
7.子集：
>>> {1,2} < {1,2,3}
True
>>> {1,2,3,4} < {1,2,3}
False
- 去重
- 只能针对不可变类型
- 集合本身是无序的，去重之后无法保留原来的顺序
>>> l1 = ['a','b','c',1,'a','b',2]
>>> j1 = set(l1)
>>> j1
{1, 2, 'a', 'b', 'c'}
针对不可变类型，并且保证顺序
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_1 = []
for dic in l:
if dic not in new_1:
new_1.append(dic)
print(new_1)
#结果：去除了重复，保证了顺序
[
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'jack', 'age': 73, 'sex': 'male'},
{'name': 'tom', 'age': 20, 'sex': 'female'}
]
七、数据类型总结
- 按存值个数区分
- 只能存一个值：可称为标量/原子类型（数字、字符串）
- 可以存放多个值：可称为容器类型（列表、元组、字典）
- 按照访问方式区分
- 直接访问：只能通过变量名访问整个值（数字）
- 顺序访问：可以用索引访问指定的值，索引代表顺序，成为序列类型（字符串、列表、元组）
- key访问：可以通过key访问指定的值（字典）
- 按可变不可变区分
- 可变类型：列表、字典
- 不可变类型：数字、字符串、元组
- 可变类型：值发生改变时，内存地址不变，证明在改变原值
- 不可变类型：值发生改变时，内存地址也变，证明没有改变原值，而是产生了新的值