基本数据类型和容器
# 基本元素
打印数据类型
a = 1
print(type(a))
//
<class 'int'>
2
3
4
# python合法命名
a
a1
a_b_c___95
_abc
_1a
// 下面这些是非法的
1
1a
1_
2
3
4
5
6
7
8
9
下面是关键词,不能用于变量命令
False class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise
2
3
4
5
6
7
# 数字
# 运算符
运算符 描述 示例 运算结果
+ 加法 5 + 8 13
- 减法 90 – 10 80
* 乘法 4 * 7 28
/ 浮点数除法 7 / 2 3.5
// 整数除法 7 // 2 3
% 模(求余) 7 % 3 1
** 幂 3 ** 4 81
2
3
4
5
6
7
8
# 基数
一般来说我们是10进制的,如果为了区分不同进制,我们可以在前面加上前缀
// 10 进制
>>> 10
10
// 2 进制
>>> 0b10
2
// 8 进制
>>> 0o10
8
// 16 进制
>>> 0x10
16
2
3
4
5
6
7
8
9
10
11
12
# 类型转换
python类型转换很强大,可以直接把字符串转换为数字
>>> int(True)
1
>>> int(False)
0
>>> int(98.6)
98
>>> int(1.0e4)
10000
>>> int('99')
99
>>> int('-23')
-23
>>> int('+12')
12
2
3
4
5
6
7
8
9
10
11
12
13
14
# 一个int类型有多大
到了 Python 3,long 类型已不复存在,而 int 类型变为可以存储任意大小的整数,甚至超 过 64 位。因此,你可以进行像下面一样计算。
>>> googol = 10**100
>>> googol
100000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000
>>> googol * googol
100000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000
2
3
4
5
6
7
8
Python 在处理超大数计算方面不会产生任何错误,这也是它的一个加分点。
# 浮点数
使用 float() 函数可以将其他数字类型转换为浮点型。与之前一样,这里就不多解释了。
>>> float('98.6')
98.6
>>> float('-1.5')
-1.5
>>> float('1.0e4')
10000.0
2
3
4
5
6
# 字符串
# 字符串创建
我们可以使用单引号或者双引号来创建字符串,这两个方法是没有区别的。还可以使用连续的三个单引号或者三个双引号来创建多行字符串,如下所示:
a = '''
hello
word
'''
b = """
aaa
vvv
ccc
"""
2
3
4
5
6
7
8
9
# str类型转换
我们可以把起来类型转换为字符串
>>>str(66)
'66'
2
# 使用\来进行转义
>>> print('a\nb')
a
b
2
3
# 使用+来进行拼接
>>> print('a'+'b')
ab
2
# 使用*来进行复制
>>> print('a'*4)
aaaa
2
# 使用[]来提取字符
>>> a='678'
>>> a[1]
'7'
2
3
当然可以提取一个范围
>>> a[1:]
'78'
>>> a[:2]
'67'
>>> a[1:2]
'7'
2
3
4
5
6
# 使用 [start:end:tep]
来进行分片
• [:] 提取从开头到结尾的整个字符串
• [start:] 从 start 提取到结尾
• [:end] 从开头提取到 end - 1
• [start:end] 从 start 提取到 end - 1
• [start:end:step] 从 start 提取到 end - 1,每 step 个字符提取一个
2
3
4
5
>>> a='123456789'
>>> a[1::2]
'2468'
>>> a[1:-1]
'2345678'
2
3
4
5
# 使用len获取长度
>>> len(a)
9
2
# 使用split来进行分割
>>> a='1,2,3,4,5'
>>> a.split(',')
['1', '2', '3', '4', '5']
2
3
# 使用join合并
>>> a = ['1','2','3']
>>> ','.join(a)
'1,2,3'
2
3
还有更多函数这里就不解释了。。自己去官网查。
# 使用replace进行替换
第一个是旧值,第二个是新值,最后一个是替换的次数
>>> a='aabbbb'
>>> a.replace('a','b',1)
'babbbb'
2
3
# 容器
# 列表
# 使用[]或list()创建列表
>>> a = [1,2,3]
>>> b = list()
>>> print(a)
[1, 2, 3]
>>> print(b)
[]
2
3
4
5
6
Python 的 list() 函数可以将其他数据类型转换成列表类型
>>> list('cat')
['c', 'a', 't']
2
# 获取列表元素
>>> a = [1,2,3]
>>> a[1]
2
2
3
列表可以包含各种元素
>>> a = [1,'2',3.5]
>>> a[2]
3.5
2
3
修改和切片就不说了。
# 使用append添加元素
>>> a = [1,2,3]
>>> a.append(4)
>>> print(a)
[1, 2, 3, 4]
2
3
4
# 使用extend或+=来合并列表
>>> print(a)
[1, 2, 3, 4]
>>> a.extend([5,6])
>>> print(a)
[1, 2, 3, 4, 5, 6]
>>> a+=[7,8]
>>> print(a)
[1, 2, 3, 4, 5, 6, 7, 8]
2
3
4
5
6
7
8
# 使用insert()在指定位置插入元素
>>> a = [1,3]
>>> a.insert(1,2)
>>> print(a)
[1, 2, 3]
2
3
4
# 使用del删除指定位置元素
>>> a = [1,2,3]
>>> del a[1]
>>> print(a)
[1, 3]
2
3
4
# 使用remove删除指定值元素
>>> a = [1,2,2,3]
>>> a.remove(2)
>>> print(a)
[1, 2, 3]
2
3
4
# 使用pop或者并删除指定位置元素
>>> a = [1,2,3]
>>> a.pop()
3
>>> print(a)
[1, 2]
2
3
4
5
# 使用index来查询特定元素的位置
1的位置在0号
>>> a = [1,2,3]
>>> a.index(1)
0
2
3
# 使用in来判断值是否存在
>>> a = [2,3,1]
>>> 1 in a
True
2
3
# count记录出现次数
>>> a = [1,2,2,3]
>>> a.count(2)
2
2
3
# 使用sort进行排序
- 列表方法 sort() 会对原列表进行排序,改变原列表内容;
- 通用函数 sorted() 则会返回排好序的列表副本,原列表内容不变。
>>> a = [5,2,3]
>>> a.sort()
>>> print(a)
[2, 3, 5]
2
3
4
>>> a = [1,5,3]
>>> sorted(a)
[1, 3, 5]
2
3
# 使用len获取长度
>>> a = [1,2,3]
>>> len(a)
3
2
3
# 使用=赋值,copy来复制
>>> a = [1,2,3]
>>> a.copy()
[1, 2, 3]
2
3
# 元组
元组也是由任意类型元素组成的序列。与列表不同的是,元组是不可变的, 这意味着一旦元组被定义,将无法再进行增加、删除或修改元素等操作,元组就像 是一个常量列表。
# 使用()来创建元祖
>>> a=(1,2,3)
>>> print(a)
(1, 2, 3)
>>> a = 1,2,3
>>> print(a)
(1, 2, 3)
2
3
4
5
6
可以把元祖赋值给多个变量,这个也叫元祖解包
>>> print(a)
(1, 2, 3)
>>> b,c,d = a
>>> print(c)
2
2
3
4
5
# 字典
字典(dictionary)与列表类似,但其中元素的顺序无关紧要,因为它们不是通过像 0 或 1 的偏移量访问的。取而代之,每个元素拥有与之对应的互不相同的键(key),需要通过键 来访问元素。键通常是字符串,但它还可以是 Python 中其他任意的不可变类型:布尔型、 整型、浮点型、元组、字符串,以及其他一些在后面的内容中会见到的类型。字典是可变 的,因此你可以增加、删除或修改其中的键值对。
# 创建字典
>>> a = {}
>>> print(a)
{}
>>> a = {1:2,'2':3}
>>> print(a)
{1: 2, '2': 3}
2
3
4
5
6
# 使用dict转换为字典
>>> a = [[1,2],[2,3],[3,4]]
>>> dict(a)
{1: 2, 2: 3, 3: 4}
>>> a = ('12','34','56')
>>> dict(a)
{'1': '2', '3': '4', '5': '6'}
2
3
4
5
6
# 获取字典的值
>>> a = {1:2,3:4}
>>> a[3]
4
2
3
# 使用update合并字典
>>> a = {1:1,2:2}
>>> b = {3:3,4:4}
>>> a.update(b)
>>> print(a)
{1: 1, 2: 2, 3: 3, 4: 4}
2
3
4
5
# 使用del删除字段
>>> print(a)
{1: 1, 2: 2, 3: 3, 4: 4}
>>> del a[1]
>>> print(a)
{2: 2, 3: 3, 4: 4}
2
3
4
5
# 使用clear删除所有元素
>>> a = {1:1,2:2}
>>> a.clear()
>>> print(a)
{}
2
3
4
# 使用in判断是否存在
>>> a = {'1':1,'2':2}
>>> 1 in a
False
>>> '1' in a
True
2
3
4
5
# 使用keys获取所有键
>>> print(a)
{'1': 1, '2': 2}
>>> a.keys()
dict_keys(['1', '2'])
2
3
4
# 使用values获取所有值
>>> print(a)
{'1': 1, '2': 2}
>>> a.values()
dict_values([1, 2])
2
3
4
# 获取items获取所有键值对
>>> print(a)
{'1': 1, '2': 2}
>>> a.items()
dict_items([('1', 1), ('2', 2)])
2
3
4
# 使用=赋值,使用copy()复制
这个不说了
# 集合
集合就像舍弃了值,仅剩下键的字典一样。键与键之间也不允许重复。如果你仅仅想知道 某一个元素是否存在而不关心其他的,使用集合是个非常好的选择。如果需要为键附加其 他信息的话,建议使用字典
# 使用set来创建集合
>>> a = set()
>>> a
set()
>>> b = {1,2,3}
>>> b
{1, 2, 3}
2
3
4
5
6
set是无序的
# 使用set把其他类型转换为集合
>>> set('aabc')
{'a', 'b', 'c'}
>>> set([1,2,3])
{1, 2, 3}
>>> set(('1','2','2'))
{'2', '1'}
2
3
4
5
6
# 使用in来判断值是否存在
这个不说了
# 集合如何合并
使用 &
运算符求交集 |
求并集 -
求差集 ^
求异或(仅在两个集合中出现一次)
>>> a = {1,2,3}
>>> b ={3,4,5}
>>> a&b 或者 a.intersection(b)
{3}
>>> a|b 或者 a.union(b)
{1, 2, 3, 4, 5}
>>> a-b 或者 a.difference(b)
{1, 2}
>>> a^b 或者 a.symmetric_difference(b)
{1, 2, 4, 5}
使用 <= 或者 issubset() 可以判断一个集合是否是另一个集合的子集
>>> a<=b
False
当第二个集合包含所有第一个集合的元素,且仍包含其他元素时,我们称第一个集合为第
二个集合的真子集。使用 < 可以进行判断:
>>> a<b
False
超集与子集正好相反(第二个集合的所有元素都出现在第一个集合中),使用 >= 或者
issuperset() 可以进行判断
>>> a>=b
False
最后,使用 > 可以找到一个集合的真超集(第一个集合包含第二个集合的所有元素且还包
含其他元素):
>>> a>b
False
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25