Python中的基本数据类型（7个）

1.Python中的基本数据类型

1.布尔型

2.数值型

3.字符串

4.列表

5.元组

6.字典

7.集合

1.布尔型

布尔型数据的算术运算 布尔型的取值只有两个，True 和 False。
可以拿来做算术运算，此时等价于 1 和 0。
布尔型数据的逻辑运算计算优先级：先算not ，再算and， 最后算or。

下列中 a = 10, b =20

2.数值型

2.1整数型

Python中的整型属于int类型，默认用十进制表示，此外，也支持二进制，八进制，十六进制表示方法。
进制转换
计算机本质上只认识二进制，但是python里面的数字还是以十进制展示的， 当然里面给我们内置了一些方法帮我们把转换为其他进制。bin()转化为二进制

a = bin(100)   #0b表示这是一个二进制数
print(a)

oct()转化为八进制

a = oct(100) # 0o表示这是一个八进制数
print(a)

hex()转化为16进制

c=hex(100) # 0x表示这是一个十六进制数
print(c)

2.2浮点型

浮点数是属于有理数当中的，Python中的浮点数就是数学当中的小数， 在运算中，整数与浮点数运算的结果依旧是浮点数。
注意：Python默认的是17位 精度，也就是小数点后最多16位。

2.3复数型

语法： a + bj
虚数不能单独存在，它们总是和一个不为0的实数一起构成一个复数。
实数部分和虚数部分都是浮点数
虚数部分必须有 j 或 J
（1）返回复数的实部

a.real

（2）返回复数的虚部

a.imag

（3）返回复数的共轭复数

a.conjugate()

共轭复数
两个实部相等，虚部互为相反数的复数互为共轭复数。
当虚部不为零时，共轭复数就是实部相等，虚部相反,如果虚部为零，其共轭复数就是自身（当虚部不等于0时也叫共轭虚数）。

2.4数值型数据的类型转换

转换为int型
将int(x)转换成整数类型
如果x是浮点型，小数点后面的数字都会砍掉，注意不是四舍五入。

a = int(2.21)
out
2

转换为float型

a = int(12)
out
12.0

2.5数值型数据的计算

下面面以a=10 ,b=20为例进行计算

加法
a+b
out
30

减法
a-b
out
-10

乘法
a*b
out
200

除法
a/b
out
0.5

取整除
9.0//2.0
out
4

取余
b/a
out
0

幂运算
a**b
out
10000000000000000000

比较运算法则

复合运算法则

Python内置的一些函数

3.字符串

不可变数据类型
有序数据类型
字符串的两种定义方式 ：
（1）通过str（）函数将其他数据类型转化为字符串
（2）直接加引号定义

3.1字符串一些运算

+号运算，收尾拼接
a = 'pyt'
b = 'hon'
a+b
out
python

*号运算，重复
a = 'pyt'
a*3
out
pytpytpyt

in 包含运算
a = '1'
b = '2332145'
a in b
out
True

3.2字符串的索引和切片

字符串切片的标准语法：
str[开始位置: 终止位置:步长和方向]
开始位置：即开始取的位置，这个位置的元素是能取到的。
终止位置：即停止的位置，注意该位置的值取不到
第三个参数:不写默认是1，正数表示从左往右取，负数表示从右往左取，绝对值表示步长。

3.3字符串对象的常用方法

（1）3个检索的方法：
str.count（）
str…count(要计数的对象，开始索引值，结束索引值) ——返回的是：你寻找的对象，在字符串里面出现的次数。
str.find（）
str.find(要查找的对象，开始位置,结束位置) ——如果对象包含在字符串内，则返回开始的索引值，否则返回-1。
str.rfind（）返回的是最后一次出现的位置。注意：find()返回的是索引值。
str.index（）
str.index（）方法同find（）方法基本一样，也是用于检索字符串类是否包含特定的对象，返回的也是索引值 ，只不过如果要检索的对象如果不存在于字符串内，不会像find（）一样返回-1，而是直接报错 。
str.rindex()是最后一次出现的位置。

（2）3个分割的方法：
str.split(“分割符”，分割次数)
str.splitlines(True或False) ——按照行分隔，返回一个包含各行作为元素的列表。 字符串.splitlines()按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表。 如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
str.partition(分隔符) ——把str以分隔符为标准，分割成三部分，str前，str和str后。

（3）1个合并的方法 ：
str.join(这里是一个包含字符串的序列)

（4）1个替换的方法：
replace（） 字符串.replace(被替换的字符, 用来替换的字符, 替换次数)
字符串是不可变数据类型，这里的所有操作返回都是新的字符串对象，原来的字符串都是没有发生变化的，如果想要去除字符串里面某个字符，可以用replace（）方法。 用来替换的字符参数为空字符即可。

（5）1个中心化的方法 ：
str.center(宽度， 填充的字符串)

（6）2个字符大小写转换方法：
str.lower（）转换str 中所有大写字符为小写。
str.upper（）转换 str 中的小写字母为大写。

（7）3个去除两端特殊字符的方法：
去除两边—— 字符串.strip(可以传入指定去除什么) 。——删除str字符串两端的空白字符以及特殊字符 这里的特殊字符包括制表符\t、回车符\r、换行符\n。
去除单边
str.rstrip（）——只去除右边的空格和特殊字符。
str.lstrip（）——只去除左边的空格和特殊字符。
（8）字符串的格式化输出1方法：
str.fromat（）的普通形式。
str.format（） 接受参数形式。

4.列表

列表是一种可变的数据类型 ，
列表中的数据类型不限 ，
列表中的多个元素之间用逗号进行分割 ，
最外层用[ ]括起来，
列表的两种定义方式 ：
使用list()将其他可迭代的数据类型转换为列表，
使用[ ]来定义。

3.1列表的一些运算

+号运算，使得列表中的所有元素存放在一个新的列表当中
a = [1, 2, 3]
b = [4, 5, [6, 7, 8]
a+b 
out
[1, 2, 3, 4, 5, [6, 7, 8]]

*号运算,重复列表当中的元素
a = [1, 2, 3]
a*3
out
[1, 2, 3, 1, 2, 3, 1, 2, 3]

in 包含运算，判断元素是否在列表当中
a = [1, 2, 3, 4, [1, 2]]
1 in a
out
True

4.2列表的索引、切片和修改

列表：有序的序列，所以每一个数据都有唯一对应的索引值。
第一个元素对应的索引值是0，和字符串是一样的，
语法：列表[开始位置:终止位置:步长和方向]，
列表[开始位置:终止位置:步长和方向]，开始的位置包含在内，终止的位置不包含在内，
步长的默认值为1，当步长设置为正整数，代表方向从左往右，当步长设置为负整数，代表从后往前进行切片，
起始位置和终止位置，如果不填，代表从头到尾所有数据。

一维列表的切片和索引
list1 = ['life', 'is', 'short', 'I', 'use', 'python']
list1[1]
out
['is']

多维列表的切片和索引
list2 = [1, 2, 3, 'Hello', [1, 2, [1, [1, '我最特殊', 3], 3], 4, 5] ]
list2[4][2][1][1]
out
['我最特殊']

列表的修改
list3 = [1, 2, 3, 'a', [1, 2, 'python']]
list3[2] = 10
list3
out
[1, 2, 10, 'a', [1, 2, 'python']]

4.3列表对象的常用方法

列表方法之增3方法：
append 语法： 原列表.append(要添加的元素) 在最后添加一个元素。
extend 语法： 原列表.extend(要添加的列表) a.extend(b)是把b每一个元素都添加到a中。
insert 语法： insert(索引，要插入的对象) insert(索引a，b)表示，把b插入到索引a所对应的元素之前。

列表方法之删4方法：
del list[要删除元素的索引值]
list.clear（） 清空列表所有元素，
list.pop(要删除元素的索引值) 默认删除最后一个，并返回这个被删除的元素，
list.remove(元素名) 用于移除列表中某个值的第一个匹配项， 若列表有多个匹配值，只会删除第一个，要想多次删除，需要用到后面学习的循环语句。

列表方法之查2方法：
list.index(寻找的对象，开始索引，结束索引) 获得某个元素首次出现的索引。
list.count(寻找的对象) 获得某个元素元素出现次数。

列表方法之排序2方法：
list.sort(reverse=True/False) 此方法会将列表按特定顺序重新排列，括号内的参数可以不写，默认升序排列，reverse的英文意思是翻转，如果填写了reverse=True就意味着列表会降序排列。
list.reverse（）将list所有元素反转。

列表的深浅拷贝：
浅拷贝只拷贝容器中元素的地址，
深拷贝，完全拷贝了一个副本，容器内部元素地址都不一样。
对于深拷贝，目的就是要创建一个玩玩全全独立的副本，就意味着所有的一切都应该在新的地址上。
1、对于列表或者字典本身，深拷贝结果下，地址是改变了的，也就是说瓶子是换新了的 。
2、所有可变类型的元素也是有了新的地址的。
3、对于不可变类型的元素，地址没有变，那岂不是相互有影响？不，如果你改变了不可变类型，就会在新的地址下储存新的数据了，也是没有影响的。

5.元组

列表是一种可变的数据类型，
列表中的数据类型不限 ，
列表中的多个元素之间用逗号进行分割 ，
最外层用[ ]括起来。
列表的两种定义方式 ：
使用list（）将其他可迭代的数据类型转换为列表，
使用[]来定义。
只含有一个元素的元组的定义，后面必须加一个逗号。

5.1元组一些运算

+号运算，把元祖的元素全部添加到一个新的元祖当中
a = (1, 2, 3)
b = (4, 5, 6)
a+b
out
（1,2,3,4,5,6）

 *号运算，重复元祖当中的元素
(1, 2)*5
 out
(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)

in包含运算, 判断元素是否在元祖当中
1 in (1, 2, 3)
out
True

5.2字符串对象的常用方法

tuple.count（）计数
tuple.index（）索引

注意：元组的不可变是指，元组本身自己的元素不可变，同理列表可变是指列表自己本身的元素可变。

tuple2 = ('a', 'b', ['A', 'B'])
tuple2[2][0] = 'X'
tuple2[2][1] = 'Y'
tuple2
out
('a', 'b', ['X', 'Y'])

6.字典

字典是一种可变数据类型 ，
点典的元素存储方式是键值对的形式，键值对之间用逗号隔开 ，
键值对的形式形如：key:value ，
最外层用{}括起来 。
d = {key1 : value1, key2 : value2 }
字典的两种定义方式：
使用dict（）来定义字典，
使用{ }来定义字典。
由于字典是键值对的形式，所以字典是无序的，自然不能切片和索引，而是通过键来取。
值键 一般是唯一的，如果重复最后的一个键值对会替换前面的。
值不需要唯一值：可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

6.2字典对象的常用方法

字典对象之增3方法：
dict[键名] = 值 增加一个新的键值对。
dict.setdefault(‘新键名’, 值) 增加一个新的键值对。
dict1.update(dict2) 把所有dic2中的键值对增加到dic1中 这个功能类似于我们在列表中学的extend()扩展功能。

字典对像之删5方法：
del 字典名[‘键名’] —— 删除指定键值对 。
字典名.pop(‘键名’) —— 删除键值+弹出值。
字典名.popitem() —— 随机删除一对(一般最后一对） 。
字典名.clear() —— 删除词典内所有元素(和列表对应操作相同） 。
del 字典名 —— 删除整个词典(和列表对应操作相同）。

字典对象之改1方法：
Dict[键名]=新值， 如果键名不存在就增加，存在就修改。

字典对象之查5方法：
dict[键] 取出该键所对应的值，
dict.get(键) 取出该键所对应的值 ，
dict.keys() 返回包含所有键的列表，这个列表不是严格意义上的list，可以用list()转换成严格意义上的列表，
dict.values() 返回包含所有值的列表，这个列表不是严格意义上的list，可以用list()转换成严格意义上的列表，
dict.items() 返回包含所有键值对的列表，每个键值对用元组储存，这个列表不是严格意义上的list，可以用 list()转换成严格意义上的列表 。

7.集合

集合是一种可变数据类型 ，
集合一种无序不重复的集，所有集合的作用主要就是去重 ，
关系测试，测试两组数据之前的交集、差集、并集等关系。
集合的定义：
使用set()定义集合，
直接使用{}来定义。.

7.1集合对象的常用方法

集合对象之增2方法：
set.add()添加元素 可以通过add(新元素)方法添加元素到set中，但对于已经存在的值不会有效果。
set.update()添加元素。

集合对象之删3方法：
set.remove（）删除指定元素。
set.pop（）随机删除一个元素并且返回这个元素。
set.celar（）清空集合。

集合的一些简单运算
in包含运算， 判断元素是否是集合中的元素
交集set1 & set2—— set1.intersection(set2)
并集set1 | set2—— set1.union(set2)