基本数据类型及内置方法

一、数字类型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访问指定的值（字典）
按可变不可变区分
- 可变类型：列表、字典
- 不可变类型：数字、字符串、元组
可变类型：值发生改变时，内存地址不变，证明在改变原值
不可变类型：值发生改变时，内存地址也变，证明没有改变原值，而是产生了新的值