Python基本数据类型有6种：
- Number数字：
int（整型）、float（浮点型）、bool（布尔）、complex（负数，eg:1.1+1.2j） - Stirng字符串
- Tuple元组
- List列表
- Dictionary字典
- Set集合
Tuple、List、Dictionary、Set为容器
其中Number、String、Tuple为不可变数据，List、Dictionary、Set为可变数据。
可以用type()函数查看变量的类型。isinstance()用来判断某变量是否为某种数据类型。
>>> b=1
>>> type(b)
<class 'int'>
>>> isinstance(b,int)
True二者的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。>>> c=True
>>> type(c)
<class 'bool'>
>>> d=1
>>> type(d)
<class 'int'>
>>> type(c)==type(d)
False
# bool为int子类，故c的数据类型属于d的数据类型，反过来则不成立
>>> isinstance(c,type(d))
True
>>> isinstance(d,type(c))
FalseNumber数字
数值类型
- int整数
- bool布尔：True/False，是int的子类
- float浮点数：浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
- complex负数：如 1+2j、1.1+2.2j
数字类型转换
- int(x)
- float(x)
- complex(x)
将x转换到一个负数，实数部分为x，虚数部分为0 - complex(x,y)
将x,y转换到一个负数，实数部分为x,虚数部分为y
数字运算
- 加减乘除：+、-、*、/
- 余数：%
- //：整数除法返回向下取整后的结果
保留的小数位数取决于分子分组的数据类型及小数位数。
>>> 7.0//2
3.0
>>> 7//2.0
3.0- 幂运算：**
数字常量
- pi：π
- e：自然常数
String字符串
创建
1、单行：包含在’ ‘或" "内
2、多行：包含在’’’ ‘’'或""" “”"
特点：这种灵活性能够在字符串中包含引号和撇号，比如:
>>> a="I love 'Python'!"
>>> a
"I love 'Python'!"转义字符
符号 | 描述 | 备注 |
| 续行符 | 用于行尾 |
| 反斜杠 | 返回\ |
| 单引号/双引号 | |
| 换行 | |
| 纵/横向制表符 | |
| 回车 | 将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 |
| 响铃 |
|
| 退格 | Backspace |
| 空 | |
| 换页 | |
| 八进制数 | y 代表 0~7 的字符，例如：\012 代表换行。 |
| 十六进制数 | 以 \x 开头，，y 代表的字符，例如：\x0a 代表换行 |
| 其它的字符以普通格式输出 |
# \v、\f、在我电脑上不能很好的显示
# 1、续行符
>>> d='Python \
... Python'
>>> d
'Python Python'
# 2、反斜杠
>>> print('\\')
\
# 3、单引号/双引号
>>> print('\'','\"')
' "
# 4、换行
>>> print('Today\n is a nice day')
Today
is a nice day
# 5、横向制表符
>>> print('Today\t is a nice day')
Today is a nice day
# 6、回车
>>> print('Today\ris a nice day')
is a nice day
>>> print('Today is a nice day.\r12345')
12345 is a nice day.
# 7、响铃
>>> print("\a")
# 会有电脑的通知声响起
# 8、退格
>>> print('Today dd\b\bis a nice day')
Today is a nice day
# 9、空
>>> print("\000")字符串运算符
利用运算符，可以实现字符串的查询或删除（切片）、增加（拼接）
- 拼接：+
>>> a='小明'
>>> b='生日快乐'
>>> c=input()
18
>>> print(a+c+'岁'+b)
小明18岁生日快乐
#如果直接加数字就要注意将数字用str()函数转换为字符串
>>> print(a+18+'岁'+b)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> print(a+str(18)+'岁'+b)
小明18岁生日快乐- 重复输出：*
>>> a='小明'
>>> print(a*4)
小明小明小明小明- 切片：变量[n]/变量[n1:n2]
变量[n]：n不能为空。通过索引获得某一字符。
变量[n1:n2]：n1和n2均可为空。遵循左闭右开原则。
- 如果n1为空，返回从下标索引0开始，到n2截止；
- 如果n2为空，返回从n1开始到字符串的最后；
- 如果n1和n2均为空，返回整个字符串。
>>> b='生日快乐'
>>>> b[2]
'快'
>>> b[:]
'生日快乐'
>>> b[1:2]
'日'
>>> b[:2]
'生日'
>>> b[2:]
'快乐'- 成员运算符：in/not in
>>> d='Python'
#区分大小写
>>> 'P' in d
True
>>> 'p' in d
False
>>> 'a' not in d
True
>>> 'a' in d
False- 原始字符串：r/R
所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。
>>> print('Today\n is a nice day')
Today
is a nice day
>>> print(r'Today \n is a nice day')
Today \n is a nice day
>>> print(R'Today \n is a nice day')
Today \n is a nice day字符串格式化
1、第一种：%
常用的集中格式化字符串符号如下：
符号 | 描述 |
| 格式化字符及其ASCII码 |
| 用rper()方法处理对象，返回对象的本体，某些时候同%s返回的有差别 |
| 格式化字符串,%s用str()方法处理对象 |
| 格式化无符号整型 |
| 格式化整数Dec |
| 格式化无符号十六进制Hex。x小写，X大写 |
| 格式化无符号八进制数Oct |
| 格式化浮点数字 |
| 用科学计数法格式化浮点数 |
|
|
|
|
格式化操作符部分辅助指令：
符号 | 描述 |
| 定义宽度或小数点精度 |
| 左对齐 |
| 正数前面显示加号 |
| 在正数前面显示空格 |
| 在八进制前面显示0,在十六进制蕲艾面显示0x |
| 补充位数,在整数前面填充0 |
| '%%'输出一个单个的% |
| 映射变量(字典参数) |
| m设置正式部分的位数，n设置小数点保留位数 |
# 0、%s和%r的区别
>>> import datetime
>>> a=datetime.date.today()
>>> print('%s'%a)
2021-12-17
>>> print('%r'%a)
datetime.date(2021, 12, 17)
# 1、*的用法，其实此处*相当于m.n，后面需指定具体值
>>> print('%s,%d'%('sssss',18))
>>> print('%*s,%0*d'%(10,'sssss',5,18))
>>> print('%*s,%05d'%(10,'sssss',18))
sssss,18
sssss,00018
sssss,00018
# 2、-左对齐
>>> print('%10s姓名,%5d年龄'%('sssss',18))
>>> print('%-10s姓名,%-5d年龄'%('sssss',18))
sssss姓名, 18年龄
sssss 姓名,18 年龄
# 3、+，正数前显示+，负数前显示-（正负得负）
>>> print('%d'%222)
>>> print('%+d'%222)
>>> print('%+d'%-222)
222
+222
-222
# 4、空格
>>> print('%d'%222)
>>> print('% d'%-222)
>>> print('% d'%222)
>>> print('%.2f'%2.222)
>>> print('% .2f'%-2.222)
>>> print('% .2f'%2.222)
222
-222
222
2.22
-2.22
2.22
# 5、#,如果不加#，八进制前面不会显示0o,十六进制前面不会显示0x或0X
>>> print('%o'% 10)
>>> print('%#o'% 10)
>>> print('%x'% 16)
>>> print('%#x'% 16)
>>> print('%#X'% 16)
12
0o12
10
0x10
0X10
# 6、m.n,总宽度为m，保留小数点n位
>>> print('%.2f'%22222.22222)
>>> print('%10.2f'%22222.22222)
>>> print('%010.2f'%22222.22222)
22222.22
22222.22
0022222.222、第二种str.format()
str.format()大多数情况与第一种用到的格式化符号差不多。具体用法如下：
- 根据位置访问
>>> print('{1},{2},{0}'.format('Tom','man',18))
man,18,Tom
>>> print('{0}{1}{0}'.format('aaa','bbb'))
aaabbbaaa- 根据名称访问
>>> print('{sex},{name},{age}'.format(name='Tom',sex='man',age=18))
man,Tom,18- 根据参数属性访问
>>> c=5-4j
>>> print('这个变量是一个复数：{0},\n它的实部为{0.real}，\n它的虚部为{0.imag}'.format(c))
这个变量是一个复数：(5-4j),
它的实部为5.0，
它的虚部为-4.0- 对齐文本以及指定宽度
# 左对齐
>>> print('|{:<10}|'.format('左对齐'))
|左对齐 |
>>> print('|{:*<10}|'.format('左对齐'))
|左对齐*******|
>>> print('|{:>10}|'.format('右对齐'))
| 右对齐|
>>> print('|{:0>10}|'.format('右对齐'))
|0000000右对齐|
>>> print('|{:^10}|'.format('居中'))
| 居中 |
>>> print('|{:0^10}|'.format('居中'))
|0000居中0000|
>>> print('|{:2^10}|'.format('居中'))
|2222居中2222|- 正负号,准确的说是正号，-负号用作左对齐
>>> print("int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(16))
int: 16; hex: 10; oct: 20; bin: 10000
>>> print('{:d}; {:+.2f}'.format(+3, -3.144444))
3; -3.14
>>> print('{:+d}; {:+.2f}'.format(3, -3.144444))
+3; -3.14
>>> print('{:-d}; {:-.2f}'.format(3, -3.144444))
3; -3.14 # 此处的3的负号不会显示- 不同进制显示
>>> print("int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(16))
int: 16; hex: 10; oct: 20; bin: 10000
>>> print("int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(16))
int: 16; hex: 0x10; oct: 0o20; bin: 0b10000- 逗号作为千位分隔符
>>> print('{:,}'.format(123456789))
123,456,789- 百分数显示
>>> print('{:.2%}'.format(15/30))
50.00%- 特定类型的专属格式化
>>> import datetime
>>> d = datetime.datetime(2021, 7, 4, 12, 15, 58)
>>> d
datetime.datetime(2021, 7, 4, 12, 15, 58)
>>> print('{:%y-%m-%d %H:%M}'.format(d))
21-07-04 12:15List列表
- 列表由一系列按特定顺序排列的元素组成。
- 包含在[]中。
- 支持任意类型对象。
创建列表
# 创建空列表
>>> list=[]
>>> list
# 创建列表
>>> list1=['xiaohong','xiaomlan','xiaohouzi']
>>> list1
['xiaohong', 'xiaomlan', 'xiaohouzi']访问元素
获得列表元素的方法：
- 下标索引
- 切片操作
- while/for循环
>>> list1=['xiaohong','xiaomlan','xiaohouzi']
# 下标
>>> list1[1]
'xiaomlan'
>>> list1[0]+' is a nice person'
'xiaohong is a nice person'
# for
>>> for l in list1:
print(l)
xiaohong
xiaomlan
xiaohouzi
# while
n=0
while n<=len(list1):
print(list1[n])
n=n+1添加元素
-
append(obj)将元素添加到列表末尾 -
extend(list_a)将某列表添加到列表末尾，
使用加号+也可以将两个列表合并为一个列表，*可以使列表重复 -
insert(index,obj)将某元素插入到列表的指定位置
>>> list1=['xiaohong','xiaomlan','xiaohouzi']
>>> list2=[18,19,20]
# 1、append()
>>> list1.append(222)
>>> list1
['xiaohong', 'xiaomlan', 'xiaohouzi', 222]
# 2、extend() + *
>>> list1+list2
['xiaohong', 'xiaomlan', 'xiaohouzi', 18, 19, 20]
>>> list2=[18,19,20]
>>> list2*2
[18, 19, 20, 18, 19, 20]
>>> list1.extend(list2)
>>> list1
['xiaohong', 'xiaomlan', 'xiaohouzi', 18, 19, 20]
# 3、insert()
>>> list1.insert(1, 222)
>>> list1
['xiaohong', 222, 'xiaomlan', 'xiaohouzi']修改元素
通过下标确认要修改的元素:list[index]=new_obj/list[start_index:stop_index]=[new_obj1,new_obj2...]
# 单元素修改
>>> list1=['xiaohong','xiaomlan','xiaohouzi']
>>> list1[2]='aaa'
>>> list1
['xiaohong', 222, 'aaa', 'xiaohouzi']
# 多元素修改
>>> list3=['xiaohong', 'xiaomlan', 'xiaohouzi', 18, 19, 20]
>>> list_a=['aaa','bbb',30]
>>> list3[1:4]=list_a
>>> list3
['xiaohong', 'aaa', 'bbb', 30, 19, 20]查找元素
-
in/not in判断某元素是否在列表中 -
index()查找某元素在列表中的位置 -
count(obj)统计某元素在列表中出现的次数
>>> list3
['xiaohong', 'aaa', 'bbb', 30, 19, 20]
# 1、in/not in
>>> 'aaa' in list3
True
>>> 'a' in list3
False
>>> 'a'not in list3
True
# 2、index()
>>> list3.index('aaa')
1
>>> list3.index(30)
3
# 3、count(obj)
>>> list3.count(30)
1删除元素/列表
-
del list_name删除整个列表 -
del list[index]/del list[start_index:end_index]根据索引进行删除 -
pop(index)根据索引删除元素，index默认为最后一个元素索引 -
remove(obj)根据列表中元素值进行删除,当有重复元素时，删除第一个匹配的元素 -
clear()清空列表
# 1、 del list[index]/ del list[start_index:end_index]
>>> list3=['xiaohong', 'xiaomlan', 'xiaohouzi', 18, 19, 20]
>>> del list3[1:3]
>>> list3
['xiaohong', 18, 19, 20]
>>> del list3[2]
>>> list3
['xiaohong', 18, 20]
# 2、 pop()
>>> list3=['xiaohong', 'xiaomlan', 'xiaohouzi', 18, 19, 20]
>>> list3.pop()
20
>>> list3
['xiaohong', 'xiaomlan', 'xiaohouzi', 18, 19]
>>> list3.pop(2)
'xiaohouzi'
>>> list3
['xiaohong', 'xiaomlan', 18, 19]
# 3、remove(obj)
>>> list3=['xiaohong', 'xiaomlan', 'xiaohouzi', 18, 19, 20]
>> list3.remove(18)
>>> list3
['xiaohong', 'xiaomlan', 'xiaohouzi', 19, 20]
# 4、clear()
>>> list3.clear()
>>> list3
[]
# 5、 del
>>> del list3
>>> list3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'list3' is not defined列表排序
-
sort( cmp=None,key=None,reverse=False)cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。 -
list.reverse()反向列表
>>> list1=[1,2,3,4,5]
>>> list1.sort()
>>> list1
[1, 2, 3, 4, 5]
>>> list1.reverse()
>>> list1
[5, 4, 3, 2, 1]
>>> list1.sort()
>>> list1.sort(reverse=True)
>>> list1
[5, 4, 3, 2, 1]复制列表
copy()
>>> list1
[5, 4, 3, 2, 1]
>>> list4=list1.copy()
>>> list4
[5, 4, 3, 2, 1]Tuple元组
- 与列表类似，但元组的元素不能修改
- 存储在()中
创建元组
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
# 创建空元组
>>> t=()
>>> t
()
# 创建元组
>>> t1=1,'q',3
>>> t1
(1, 'q', 3)
>>> t2=('tom','lily','sam')
>>> t2
('tom', 'lily', 'sam')访问元素（同列表相同）
获得元组元素的方法(同列表一样)：
- 下标索引
- 切片操作
- while/for循环
修改元组
元组内元素不允许修改，但是可以一些运算方法实现元组内元素的增减
-
+两个元组合并 -
*元组重复
# +
>>> t1=(1,2,3,4)
>>> t2=(5,6,7)
>>> t1+t2
(1, 2, 3, 4, 5, 6, 7)
# *
>>> t2*2
(5, 6, 7, 5, 6, 7)- 拆分
>>> t2
(5, 6, 7)
>>> a,b,c=t2
>>> a
5
>>> b
6
>>> c
7
>>> t3=3,4,(5,6)
>>> t3
(3, 4, (5, 6))
>>> e,d,f=t3
>>> e
3
>>> d
4
>>> f
(5, 6)
>>> e,d,(f,g)=t3
>>> f
5
>>> g
6
>>> t1
(1, 2, 3, 4)
>>> h,k,*_=t1 # *_如果为需要舍弃的部分，命名不重要，此处用_代替
>>> h
1
>>> k
2
>>> _
[3, 4]查找元素（同列表相同）
-
in/not in判断某元素是否在列表中 -
index()查找某元素在列表中的位置 -
count(obj)统计某元素在列表中出现的次数
>>> t1
(1, 2, 3, 4)
# 1、in/not in
>>> 1 in t1
True
# 2、index()
>>> t1.index(1)
0
# 3、count()
>>> t1.count(1)
1删除元组
del tuple_nameDictionary字典
- 可变容器模型，可存储任意类型对象
- 包含在{}中，由key:value组成
- 键key必须是唯一的，但值不必
- 值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
创建字典
# 1、创建空字典
>>> d1={}
>>> d1
{}
# 2、创建字典
>>> d2={'name':'xiaoming','sex':'man','age':18}
>>> d2
{'name': 'xiaoming', 'sex': 'man', 'age': 18}
# 3、dict.fromkeys(seq[, value])
>>> d5=dict.fromkeys(seq)
>>> d5
{'aa': None, 'bb': None}访问元素
-
dict[key]通过key,获取相应value -
dict.keys()返回迭代器，用list()/tuple()将key值转换为列表/元组 -
dict.values()返回迭代器，用list()/tuple()将value值转换为列表/元组 -
dict.items()返回可遍历的（key,value）元组数组 - for循环遍历
>>> d2={'name':'xiaoming','sex':'man','age':18}
>
# dict[key]
>>> d2['name']
'xiaoming'
# dict.keys()
>>> d2.keys()
dict_keys(['name', 'sex', 'age'])
>>> list(d2.keys())
['name', 'sex', 'age']
>>> tuple(d2.keys())
('name', 'sex', 'age')
# dict.values()
>>> d2.values()
dict_values(['xiaoming', 'man', 18])
>>> list(d2.values())
['tom', 'man', 18]
>>> tuple(d2.values())
('tom', 'man', 18)
# dict.items()
>>> d2.items()
dict_items([('name', 'xiaoming'), ('sex', 'man'), ('age', 18)])
# for/dict.keys()/dict.values()/dict.items()
>>> for k in d2.keys():
... print(k)
...
name
sex
age
>>> for v in d2.values():
... print(v)
...
xiaoming
man
18
>>> for k,v in d2.items():
... print(k,v)
...
name xiaoming
sex man
age 18添加元素
-
dict[new_key]=new_value通过key值修改相应value值 -
dict1.update(dict2)将另一字典更新到当前字典中，如果有相同key值不会更新改key:value组 -
dict.setdefault(key,defaule=None)如果key不存在字典中，添加新的key,value可指定，默认为None
# dict[new_key]=new_value
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18}
>>> d2['interest']='reading'
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading'}
# dict1.update(dict2)
>>> d3
{'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading'}
>>> d2
{'name': 'tom', 'sex': 'man'}
>>> d2.update(d3)
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading'}
>>> d4={1:123,2:456}
>>> d2.update(d4)
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading', 1: 123, 2: 456}
# dict.setdefault(key,defaule=None)
>>> d2.setdefault(3)
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading', 1: 123, 2: 456, 3: None}修改元素（修改value值)
key值不可修改，只能修改value值dict[old_key]=new_value通过key值修改相应value值
# dict[old_key]=new_value
>>> d2={'name':'xiaoming','sex':'man','age':18}
>>> d2['name']='tom'
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18}查找元素
key in dict只能判断key是否在字典中，不能用于判断value
# key in dict
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading', 1: 123, 2: 456}
>>> 'name' in d2
True
>>> 'tom' in d2
False删除元素/字典
-
del dict[key]删除某个元素，根据key值定位 -
dict.pop(key)删除某个元素，根据key值定位 -
dict.popitem()删除最后一对key:value -
del dict_name删除整个字典 -
dict.clear()清空整个字典
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading'}
# del dict[key]
>>> del d2['interest']
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18}
# dict.pop(key)
>>> d2={'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading'}
>>> d2.pop('interest')
'reading'
>>> d2
{'name': 'tom', 'sex': 'man', 'age': 18}
# dict.popitem()
>>> d2.popitem()
('age', 18)
>>> d2
{'name': 'tom', 'sex': 'man'}
# dict.clear()
>>> d2.clear()
>>> d2
{}
# del dict_name
>>> del d2
>>> d2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'd2' is not defined复制字典
>>> d3=d2.copy()
>>> d3
{'name': 'tom', 'sex': 'man', 'age': 18, 'interest': 'reading'}Set集合
- 无序不重复的元素序列
- 存储在{}中
- 因为无序，不能使用索引查询
- 常用功能，进行成员关系测试和删除重复元素
创建集合
# 创建空集合，不能使用s={},这是创建字典的方式
>>> s=set()
>>> s
set()
>>> type(s)
<class 'set'>
>>> s3={}
>>> type(s3)
<class 'dict'>
# 创建集合
>>> s2={'tom','lily'}
>>> s2
{'lily', 'tom'}访问元素
for循环遍历
>>> for ss in s2:
... print(ss)
...
lily
tom添加元素
-
set.add(obj)添加元素 -
set.update(iterable_obj)添加元素，iterable_obj为可迭代对象，如：元组、列表、dict.keys()、dict.values()
# set.add(obj)
>>> s2={'tom','lily'}
>>> s2.add(2)
>>> s2
{2, 'lily', 'tom'}
# set.update(obj)
>>> s4={1,2}
>>> s2.update(s4)
>>> s2
{1, 2, 'lily', 'tom'}删除元素
-
s.remove(obj)元素不存在会发生错误 -
s.discard(obj)元素不存在不会发生错误 -
s.popa()随机删除集合中的一个元素 -
s.clear()清空集合 -
del set_name删除整个集合
复制集合
>>> s={'aaa','bbb'}
>>> s1=s.copy()
>>> print(s1)
{'bbb', 'aaa'}其他函数
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
