一、数字类型(Number)
- Python 数字数据类型用于存储数值。
- 数据类型是不允许改变的,这就意味着如果改变数字数据类型的值,将重新分配内存空间。
数字类型的创建:
num = 1
num1 = 10
num2 = 100
Python 支持三种不同的数值类型:
- 整型(Int) - 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 102 = 250)
- 复数( (complex)) - 复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。
数字类型转换
序号 | 方法 | 作用 |
---|---|---|
1 | int(xx) | 将xx转换为一个整数 |
2 | float(xx) | 将xx转换为一个浮点数 |
3 | complex(xx) | 将xx转换成一个复数,实数部分为xx,虚数部分为0 |
4 | comple(xx, yy) | 将xx和yy转换成一个复数, 实数部分为xx,虚数部分为yy,xx和yy是数字表达式 |
代码示例:
# 1. int
l1 = 10.22
print(int(l1))
----------run----------
10
# 2. float
l1 = 10
print(float(l1))
----------run----------
10.0
# 3. complex
l3 = 10
print(complex(l3))
----------run----------
(10+0j)
# 4. complex
l4 = 10
l5 = 20
print(complex(l4, l5))
----------run----------
(10+20j)
数学函数
函数 | 作用 | 示例变量赋值 | 示例 | print(‘示例’) |
---|---|---|---|---|
abs(x) | 返回数字的绝对值 | x = -30 | abs(x) | 30 |
ceil(x) | 返回数字的上入整数 | x = 9.1 | ceil(x) | 10 |
floor(x) | 返回数字的下舍整数 | x = 9.9 | floor(x) | 9 |
max(x, y) | 返回给定参数的最大值 | x = 10, y = 20 | max(x, y) | 20 |
min(x, y) | 返回给定参数的最小值 | x = 10, y = 20 | min(x, y) | 10 |
pow(x, y) | 返回x**y运算后的值 | x = 2,y = 4 | pow(x, y) | 16 |
round(x,n) | 返回四舍五入值,n为指定保留小数位 | x = 1.11111 | round(x, 3) | 1.111 |
随机数函数
函数 | 作用 | 示例变量赋值 | 示例 | print(‘示例’) | 注意 |
---|---|---|---|---|---|
choice(x) | 从序列的元素中随机挑选一个元素 | x = 10 | random.choice(range(x)) | 随机0-9 | 需导入random模块 |
randrange (x, y]) | 从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1 | x = “最小值”,y = “最大值” | random.randrange(x, y) | 随机0-100 | 需导入random模块 |
random(x) | 随机生成下一个实数,在0-1范围内 | random.random() | 随机0-1 | 需导入random模块 | |
seed(x) | 改变随机数生成器的种子,可以在调用其他随机模块函数之前调用此函数 | x = 1 | random.seed(x) | 0.13436424411240122 | 需导入random模块 |
shuffle(x) | 方法将序列的所有元素随机排序 | x = [1, 2, 3, 4] | random.shuffle(x) | 随机排序‘l1’列表中数据 | 需导入random模块 |
uniform(x, y) | 随机生成一个浮点数,在x, y范围内 | x = 1,y = 10 | random.uniform(x, y) | 随机1-10中的浮点数 | 需导入random模块 |
二、字符串(String)
- 字符串是 Python 中最常用的数据类型。我们可以使用引号(‘或”)来创建字符串。
字符串的创建
str1 = 'Hello'
str2 = 'hi'
字符串拼接
str1 = 'Hello World'
str2 = 'hi'
str3 = str2 + ' ' + str1[6:0]
print(str3)
----------run----------
Hi World
转义字符
字符 | 作用 |
---|---|
\ (在行尾使用) | 续行符 |
\\ | 反斜杠符号 |
\’ | 单引号 |
\” | 双引号 |
\a | 响铃 |
\b | 退格(Backspace) |
\e | 转义 |
\000 | 空 |
\n | 换行 |
\v | 纵向制表符 |
\t | 横向制表符 |
\r | 回车 |
\f | 换页 |
\oyy | 八进制数,yy代表的字符,例如:\o12代表换行 |
\xyy | 十六进制数,yy代表的字符,例如:\x0a代表换行 |
\other | 其它的字符以普通格式输出 |
字符串运算符
操作符 | 作用 | 示例变量赋值 | 示例 | print(‘示例’) |
---|---|---|---|---|
+ | 字符串连接 | a = ‘Hello’,b = ‘World’ | a + b | HelloWorld |
* | 重复输出字符串 | a = ‘Hello’ | a*2 | HelloHello |
[] | 通过索引获取字符串中字符 | a = ‘Hello’ | a[1] | e |
[ : ] | 截取字符串中的一部分 | a = ‘Hello’ | a[1:4] | ell |
in | 成员运算符 - 如果字符串中包含给定的字符返回 True | a = ‘Hello’ | ‘H’ in a | True |
not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | a = ‘Hello’ | ‘M’ not in a | True |
r/R | 原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。 | print( r’\n’ )print( R’\n’ ) | ||
% | 格式字符串 |
字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式,但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
示例:
name = '李四'
age = 18
print("我叫"%s,今年%d岁!(name, age)
----------run----------
我叫李四,今年18岁!
字符串格式化符号:
符号 | 作用 |
---|---|
%c | 格式化字符及其ASCII码 |
%s | 格式化字符串 |
%d | 格式化整数 |
%u | 格式化无符号整型 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数(大写) |
%f | 格式化浮点数 |
%e | 用科学计数法格式化浮点数 |
%p | 用十六进制数格式化变量的地址 |
- | - |
格式化操作符辅助命令 | |
* | 定义宽度或者小数点精度 |
- | 用做左对齐 |
+ | 在正数前面显示加号( + ) |
<sp> | 在正数前面显示空格 |
# | 在八进制数前面显示零(‘0’),在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) |
0 | 显示的数字前面填充’0’而不是默认的空格 |
% | ‘%%’输出一个单一的’%’ |
(var) | 映射变量(字典参数) |
m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
Unicode 字符串
在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中,所有的字符串都是Unicode字符串。
字符串内置函数
函数 | 作用 |
---|---|
capitalize() | 将字符串的第一个字符转换为大写 |
center(width, fillchar) | 返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。 |
count(str, beg= 0,end=len(string)) | 返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
bytes.decode(encoding=”utf-8”, errors=”strict”) | Python3 中没有 decode 方法,但可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。 |
encode(encoding=’UTF-8’,errors=’strict’) | 以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是’ignore’或者’replace’ |
endswith(suffix, beg=0, end=len(string)) | 检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,是则返回 True,否则返回 False. |
expandtabs(tabsize=8) | 把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。 |
find(str, beg=0 end=len(string)) | 检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1 |
index(str, beg=0, end=len(string)) | 跟find()方法一样,只不过如果str不在字符串中会报错. |
isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
isdigit() | 如果字符串只包含数字则返回 True 否则返回 False.. |
islower() | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False |
isnumeric() | 如果字符串中只包含数字字符,则返回 True,否则返回 False |
isspace() | 如果字符串中只包含空白,则返回 True,否则返回 False. |
istitle() | 如果字符串是标题化的(见 title())则返回 True,否则返回 False |
isupper() | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False |
join(seq) | 指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
len(string) | 返回字符串长度 |
ljust(width, fillchar) | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。 |
lower() | 转换字符串中所有大写字符为小写. |
lstrip() | 截掉字符串左边的空格或指定字符。 |
maketrans() | 创建字符映射的转换表 |
max(str) | 返回字符串 str 中最大的字母。 |
min(str) | 返回字符串 str 中最小的字母。 |
replace(old, new, max) | 把 将字符串中的 str1 替换成 str2,如果 max 指定,则替换不超过 max 次。 |
rfind(str, beg=0,end=len(string)) | 类似于 find()函数,不过是从右边开始查找. |
rindex( str, beg=0, end=len(string)) | 类似于 index(),不过是从右边开始. |
rjust(width, fillchar) | 返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串 |
rstrip() | 删除字符串字符串末尾的空格. |
split(str=”“, num=string.count(str)) | num=string.count(str)) 以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num 个子字符串 |
splitlines([keepends]) | 按照行(‘\r’, ‘\r\n’, \n’)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。 |
startswith(str, beg=0,end=len(string)) | 检查字符串是否是以 obj 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。 |
strip([chars]) | 在字符串上执行 lstrip()和 rstrip() |
swapcase() | 将字符串中大写转换为小写,小写转换为大写 |
title() | 返回”标题化”的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle()) |
translate(table, deletechars=”“) | 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
upper() | 转换字符串中的小写字母为大写 |
zfill (width) | 返回长度为 width 的字符串,原字符串右对齐,前面填充0 |
isdecimal() | 检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。 |
三、列表(List)
- 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推。
列表的创建
list1 = [1, 2, 3, 4]
list2 = [5, 6, 7, 8]
更改列表中数据
:
list = ['张三', '李四', 3, 4, 5]
print (list[3])
list[3] = '王五'
print (list[3])
----------run----------
4
王五
列表中数据删除
list = [1, 2, 3, 4, 5]
print (list)
del list[2]
print (list)
----------run----------
[1, 2, 3, 4, 5]
[1, 2, 4, 5]
列表相关操作命令
函数 | 作用 |
---|---|
len(list) | 列表元素个数 |
max(list) | 回列表元素最大值 |
min(list) | 返回列表元素最小值 |
list(seq) | 将元组转换为列表 |
方法 | 作用 |
---|---|
.append() | 在列表末尾添加新的对象 |
.count() | 统计某个元素在列表中出现的次数 |
.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
.index() | 从列表中找出某个值第一个匹配项的索引位置 |
.insert(index, obj) | 将对象插入列表 |
.pop([index=-1]]) | 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 |
.remove(obj) | 移除列表中某个值的第一个匹配项 |
.reverse() | 反向列表中元素 |
.sort(cmp=None, key=None, reverse=False) | 对原列表进行排序 |
.clear() | 清空列表 |
.copy() | 复制列表 |
四、元组(Tuple)
- 元组与列表类似,不同之处在于元组的元素不能修改。
- 元组使用小括号,列表使用方括号。
元组的创建:
tup1 = ()
注意:
# 1.不加逗号,类型为整型
tup1 = (50)
print(type(tup1))
----------run----------
<class 'int'>
# 2.加上逗号,类型为元组
tup1 = (50,)
print(type(tup1))
----------run----------
<class 'tuple'>
查看元组示例
tup1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tup1[1])
print(tup1[2:5])
----------run----------
2
(3, 4, 5)
合并元组示例
tup1 = (1, 2, 3, 4)
tup2 = ('北京', '河北', '燕郊')
tup3 = tup1 + tup2
print(tup3)
----------run----------
(1, 2, 3, 4, '北京', '河北', '燕郊')
删除元组示例
tup1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tup1)
del(tup1)
print(tup1)
----------run----------
(1, 2, 3, 4, 5, 6, 7, 8)
# 删除元组后会打印出现报错
Traceback (most recent call last):
print(tup1)
NameError: name 'tup1' is not defined
切片方法提取元组内数据
tup1 = '123456789'
tup2 = "赵钱孙李"
print(tup1[2])
print(tup1[-3])
print(tup1[2:])
print(tup1[1::2])
print(tup2[2])
print(tup2[-3])
print(tup2[2:])
print(tup2[1::2])
----------run----------
3
7
3456789
2468
孙
钱
孙李
钱李
元组内置函数
方法 | 作用 |
---|---|
len() | 计算元组元素个数 |
max(tuple) | 返回元组中元素最大值 |
min(tuple) | 返回元组中元素最小值 |
tuple(seq) | 将列表转换为元组 |
五、集合(Set)
- 集合(set)是一个无序不重复元素的序列。
- 可以使用大括号 { } 或者 set() 函数创建集合
注意:
创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
集合的创建
set1 = {'张三', '李四'}
print(set1)
----------run----------
{'张三', '李四'}
l1 = set('赵钱孙李')
print(l1)
----------run----------
{'孙', '赵', '李', '钱'}
集合之间的运算
set1 = set('赵钱孙李周吴郑王')
set2 = set('一钱一李一吴一王')
print(set1-set2)
print(set1 | set2)
print(set1 & set2)
print(set1 ^ set2)
----------run----------
{'孙', '赵', '周', '郑'} # 集合a中包含元素
{'钱', '吴', '孙', '周', '李', '郑', '王', '一', '赵'} # 集合a或b中包含的所有元素
{'钱', '李', '王', '吴'} # 集合a和b中都包含了的元素
{'孙', '周', '郑', '一', '赵'} # 不同时包含于a和b的元素
集合推导式(Set comprehension)
set1 = {i for i in '123231234' if i not in '23'}
print(set1)
----------run----------
{'1', '4'}
集合的增
添加到集合 s 中,如果元素已存在,则不进行任何操作。
t1 = set('赵钱孙李')
t1.add('周')
t1.add('李')
print(t1)
----------run----------
{'周', '赵', '钱', '李', '孙'}
集合的删
remove()方法,要删除集合中目标数据不存在会发生错误
set1 = set('赵钱孙李周吴郑王')
set1.remove('李')
print(set1)
set1.remove('一')
print(set1)
----------run----------
{'钱', '郑', '周', '赵', '孙', '吴', '王'}
Traceback (most recent call last):
set1.remove('一')
KeyError: '一'
discard()方法,要删除集合中目标数据不存在,也不会报错
set1 = set('赵钱孙李周吴郑王')
set1.discard('一')
print(set1)
set1.discard('李')
print(set1)
----------run----------
{'李', '王', '钱', '周', '吴', '孙', '郑', '赵'}
{'王', '钱', '周', '吴', '孙', '郑', '赵'}
pop()方法,随机删除集合中的数据
set1 = set('赵钱孙李周吴郑王')
set1.pop()
print(set1)
----------run----------
{'吴', '郑', '钱', '孙', '周', '赵', '李'}
clear()方法,清空集合
set1 = set('赵钱孙李周吴郑王')
set1.clear()
print(set1)
----------run----------
set()
判断某元素是否在集合中
set1 = set('赵钱孙李周吴郑王')
print('李' in set1)
print('一' in set1)
print('一' not in set1)
----------run----------
True
False
True
六、字典(Dictionary)
- 字典是另一种可变容器模型,且可存储任意类型对象。
- 字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中。
- 键必须是唯一的,但值则不必。
- 值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
字典键的特性
字典值可以是任何的 python 对象,既可以是标准的对象,也可以是用户定义的,但键不行。
两个重要的点需要记住
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住
- 键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行
字典的创建
dict = {'name': 'Kinney', 'age': '18', 'hoppy': 'Music'}
dict1 = { 'name': 'Kinney'};
dict2 = { 'name': 'Kinney', age: 18};
字典的查
dict = {'name': 'Kinney', 'age': '18', 'hoppy': 'Music'}
print(dict['name'])
print(dict['age'])
----------run----------
Kinney
18
如果字典中没有要查找的数据则会报错
Traceback (most recent call last):
print(dict['key'])
KeyError: 'key'
字典的改
dict = {'name': 'Kinney', 'age': '18', 'hoppy': 'Music'}
print(dict['name'])
print(dict['age'])
dict['name'] = 'db'
dict['age'] = 99
print(dict['name'])
print(dict['age'])
----------run----------
Kinney
18
db
99
字典的删
del()方法,删除字典中指定key,也可以删除字典
clear()方法,清空字典
dict = {'name': 'Kinney', 'age': '18', 'hoppy': 'Music'}
del dict['hoppy']
print(dict)
dict.clear()
print(dict)
del dict
print(dict)
----------run----------
{'age': '18', 'name': 'Kinney'}
{}
<class 'dict'>
字典内置函数
函数 | 作用 |
---|---|
len(dict) | 计算字典元素个数,即键的总数 |
str(dict) | 输出字典,以可打印的字符串表示 |
type(variable) | 返回输入的变量类型,如果变量是字典就返回字典类型 |
字典内置方法
函数 | 作用 |
---|---|
radiansdict.clear() | 删除字典内所有元素 |
radiansdict.copy() | 返回一个字典的浅复制 |
radiansdict.fromkeys() | 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值 |
radiansdict.get(key, default=None) | 返回指定键的值,如果值不在字典中返回default值 |
key in dict | 如果键在字典dict里返回true,否则返回false |
radiansdict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
radiansdict.keys() | 返回一个迭代器,可以使用 list() 来转换为列表 |
radiansdict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default |
radiansdict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
radiansdict.values() | 返回一个迭代器,可以使用 list() 来转换为列表 |
pop(key[,default]) | 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值 |
popitem() | 随机返回并删除字典中的一对键和值(一般删除末尾对) |