python 人生苦短，我学Python

Posted 2021-09-07 IT_Holmes

文章目录

• 1. range()
• 2. 元组（tuple）
• • 2.1 元组 简介
  • 2.2 创建元组 和 元组注意事项
  • 2.3 元组的解包（解构）
• 3. 可变对象 注意事项
• 4. == ， != ， is ， is not
• 5. 字典(dict)
• • 5.1 字典 介绍
  • 5.2 字典 创建 和 注意事项
  • 5.3 字典 常用的函数
  • 5.4 字典遍历
• 6. 集合
• • 6.1 集合 介绍
  • 6.2 集合 创建
  • 6.3 集合的运算

1. range()

range()是一个函数，可以用来生成一个自然数的序列。

该函数需要三个参数：

• 起始位置(可以省略，默认为0) 。
• 结束为止
• 步长(可以省略，默认为1) ,也可以是负数(起始位置要比结束为止大！)。

	range(0,20,1);  # 整数
	range(20,0,-1);  # 负数

通过range()可以创建一个执行指定次数的for循环。

	for i in range(20,0,-2):
	print(i);

2. 元组（tuple）

2.1 元组 简介

元组是一个不可变的序列。

他的操作的方式基本上和列表是一致的。

操作元组时，就把它当成一个不可变的列表就可以了，索引切片都可以在元组使用。

什么使用使用元组？
答：一般当我们希望数据不改变时，就使用元组，其余情况都是用列表。

2.2 创建元组 和 元组注意事项

创建元组：
使用 ( ) 来创建元组。

最注意的是元组是不可变对象，不能对元组中的元素重新赋值。

当元组不是空元组时，括号可以省略。
如果元组不是空元组，它里面至少要有一个 ，(逗号)。

my_tuple = 10,20,30,40
my_tuple2 = 50, #一定要加上,号，不然他不识别为元组。

2.3 元组的解包（解构）

解包就是将元组当中每一个元素都赋值给一个变量。

my_tuple = 10,20,30,40

a,b,c,d = my_tuple;

print(a); # 10
print(b); # 20
print(c); # 30
print(d); # 40

这种操作很方便，例如我们要交互a和b的值，这时我们就可以利用元组的解包来实现。

a = 111;
b = 222;
print(a,b);  # 111 222

a,b = b,a;
print(a,b); # 222 111

在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致。
也可以再变量前面添加一个 * ，这样变量将会获取元组中所有剩余的元素。

my_tuple = 10,20,30,40;

a,b,*c = my_tuple;

print(a); # 10
print(b); # 20
print(c); # 返回的是列表，[30, 40]

这里的 * 可以随便放置，给a，给b都可以。但是不能同时出现两个 * 的状况。

此外，除了元组，字符串也是可以解包的。

str = 'hello world'

a,b,*c = str;

print(a); 
print(b); 
print(c);  # 结果如下：

3. 可变对象 注意事项

可变对象中，最需要注意的是两点：

一个叫做改对象，一个叫做改变量。

改对象：就是修改变量里面的元素值。

a = [1,2,3];
print(id(a[0])); 
print(id(a));

a[0] = 5; # 仅仅是将变量a中的第一个对象修改了。

print(a);
print(id(a[0])); # 变量内部第一个元素地址发生变化
print(id(a)); # 但是变量本省地址没有发生变化

改变量：就是将变量本身改变。

a = [1,2,3];
print(id(a));

a = [1,2]; # 这里呢，就是改变量，整个a重新赋值。
print(id(a));

总结一下，一般只有在为变量重新赋值时，就是改变量，其余的都是修改对象。

4. == ， != ， is ， is not

== 和 != 比较的是对象的值是否相等。

is 和 is not 比较的是对象的id是否相等(比较对象是否是同一个对象)。

a = [1,2,3];
b = [1,2,3];

print(a == b);

print(id(a),id(b)); # 值虽然相同，但id不同(内存地址不同)，因此使用is返回False。
print(a is b);

5. 字典(dict)

5.1 字典 介绍

• 字典属于一种新的数据结构，称为映射（mappding）。
• 字典的作用和列表类似，都是用来存储对象的容器。
• 列表存储数据的性能很好，但是查询数据的性能很差。而在查询元素时，字典的效率时非常快的。
• 在字典中每一个元素都有一个唯一的名字，同故宫这个唯一的名字可以快速的查找到指定的元素。
• 在字典中可以报错多个对象，每个对象都会有一个唯一的名字,也就是键(key)；这个对象，我们称其为值(value)。也就是所谓的键值对(key-value)结构。

每一个键值对，我们叫它为一项(item)。

5.2 字典 创建 和 注意事项

使用{ }来创建字典。
还可以使用dict()函数创建字典。

语法：
{key:value,key:value,key:value …}

注意事项：

• 字典的键是不能重复的，如果出现重复的后边的会替换到前边的。
• 字典是根据键来获取值。如果使用了字典中不存在的键，会报错。

d = {'name':'张三','age':80,'gender':'男','name':'李四'};

print(d,type(d));

print(d['name']);

5.3 字典 常用的函数

使用dict()函数来创建字典。

每一个参数都是键值对，参数名就是键，参数名就是值(这种方式创建的字典，key都是字符串)。

c = dict(name='张三',age=80,gender='男');
print(c,type(c));

还可以将一个包含有双值子序列的序列转换为字典
双值序列，序列中只有两个值，例如：[1,2] ， [ ‘a’,3] ， ‘ab’ 等等。

子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列。例如：[(1,2),(3,5)]

b = dict([('name','张三'),('age',800)]);
print(b , type(b));   # 结果：{'name': '张三', 'age': 800} <class 'dict'>

函数：len()获取字典中键值对的个数

b = dict([('name','张三'),('age',800)]);
print(len(b));  # len(b)

in 检查字典中是否包含指定键，not in 检查字典中是否不包含指定的键。返回True 或者 Fasle

b = dict([('name','张三'),('age',800)]);
print('name' in b); # True
print('sex' in b); # False
print('sex' not in b); # True

获取字典中的值，根据键来直接获取值，需要注意的是要加引号，因为它识别字符串形式。此外还有get函数方式获得值。

b = dict([('name','张三'),('age',800)]);
print(b['name']); # 这里一定要加引号，不然默认识别是一个变量了

这种直接获取的方式，如果获得目标值不存在，就会报错KeyError。而get函数返回None，这点比直接获取要好一点。

函数：get(key，[default]),该方法用来根据键来获取字典中的值。
default作用就是当key值不存在时，他就会返回default中的内容。默认返回None，这一点比直接查询好。

b = dict([('name','张三'),('age',800)]);
print(b.get('sex','这个数值不存在'));

修改字典:直接索引添加
存在则覆盖，不存在则添加。

函数：setdefault(key,[default])，用来向字典添加key-value(键值)
如果key已经存在与字典中，则返回字典中key的值，不会对字典做任何操作。

如果key不存在，则向字典中添加这个key，设置value(这里的value就是上面的default)。

b = dict([('name','张三'),('age',800)]);

result = b.setdefault('name','李四');
result2 = b.setdefault('sex','男');
print(result); # 张三
print(b); # {'name': '张三', 'age': 800, 'sex': '男'}

函数：update([other]) ,将其他的字典中的key-value添加到当前字典中

注意如果有重复的key，后边的会替换到当前的值。如下面的a键。

d = {'a':1,'b':2,'c':3};
d2 = {'d':4,'e':5,'f':6,'a':7};
d.update(d2); # 将d2添加到d中。
print(d); # {'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

函数：del 来删除字典中的key-value。

函数：popitem()，随机删除字典中的一个键值对，一般都会删除最后一个键值对。它的返回值是一个元组。

需要注意的时，popitem()是有返回值的，返回的是一个元组tuple。

popitem()在删除一个空字典时，会抛出异常。

d = {'a':1,'b':2,'c':3};
result = d.popitem();
print(result,type(result)); # ('c', 3) <class 'tuple'>

函数：pop(key,[default]),根据key删除字典中的key-value。它也有返回值，会将被删除的value值返回。

如果删除不存在的key，会抛出异常。但是指定了default默认值，再删除不存在的key时，不会报错，而是直接返回默认值。

d = {'a':1,'b':2,'c':3};
result = d.pop('f','该数据不存在');
print(result);

函数：clear()函数，清空字典

函数：copy()，该方法用于对字典进行浅复制。注意浅复制的浅字，要注意！

d = {'a':1,'b':2,'c':3};
d2 = d;  # 注意这不是复制，因为d2和d指向同一个字典地址。

d2 = d.copy(); # 这才是复制。
print(d,id(d)); # {'a': 1, 'b': 2, 'c': 3} 1579142555072
print(d2,id(d2));  # {'a': 1, 'b': 2, 'c': 3} 1579142555136
# 地址不同，这才是复制，换句话说就是复制后的对象和原对象是独立的，修改一个不会影响另一个。

注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制。例如：

d = {'a':{'name':"张三",'age':20},'b':2,'c':3};

d2 = d.copy();

d2['a']['name'] = '李四';

print(d); # 你会发现我们仅仅修改了d2的a值的name值，d也会跟着变化。
print(d2); 

# 因为是浅复制，所以对象内部的对象，它是不会复制的。

5.4 字典遍历

函数：keys() 该方法会返回字典的所有的key。返回值为一个序列。
keys()配合for … in 可以遍历所有获取的键。

函数：values(),获取所有字典的值，返回值为一个序列。
同样配合for in使用。

函数：items()，返回字典中所有的项。
同样配合for in使用，但这里要传递两个值，因为一个项包含键和值。

d = {'a':{'name':"张三",'age':20},'b':2,'c':3};
for k,v in d.items():
	print(k,'=',v);

6. 集合

6.1 集合 介绍

集合和列表非常相似。

• 集合中只能存储不可变对象。
• 集合中存储的对象是无序(不是按照元素的插入顺序保存)
• 集合中不能出现重复元素。

6.2 集合 创建

使用{ }创建集合。

这里有个疑点，集合和字典容易混淆，集合的内容无序且没有键值对的形式。

s = {1,2,3,4,5};

print(s,type(s)); # {1, 2, 3, 4, 5} <class 'set'>

集合中的元素是不能重复的。如果重复了最后显示也只是显示一个内容而已。

s = {1,2,3,4,5,1,1,1,1,1,1,1};

print(s,type(s)); # {1, 2, 3, 4, 5} <class 'set'>

集合只能存储不可变的对象，如数值，字符串。

使用set()函数来创建集合和将序列和字典转换集合。

set可以将序列和字典转换为集合。注意：转换字典只包含键，不包含值。

a = set([1,2,3,4,5]); # list 列表转换为集合
b = set('hello');  # String 字符串转换为集合
c = set({'a':1,'b':2,'c':3}); # dict 字典转换为集合
print(a,type(a)); # {1, 2, 3, 4, 5} <class 'set'>
print(b,type(b)); # {'h', 'o', 'e', 'l'} <class 'set'>
print(c,type(c)); # {'b', 'c', 'a'} <class 'set'>

定义一个空集合，空字典

s = set(); # 定义空集合 <class 'set'>
s = {} # 定义空字典 <class 'dict'>

集合是没法通过索引取值的，但可以通过转换类型方式实现，如转换为list列表。

a = set([1,'a','b',4,5]); 

print(list(a)[0]);
print(list(a)[1]);
print(list(a)[2]);
print(list(a)[3]); 
print(list(a)[4]); # 通过转换为list获取值。

使用in 和 not in 来检查集合中的元素

a = set([1,'a','b',4,5]); 

print('a' in a);
print('a' not in a);

使用len()来获取集合中元素的数量

使用add()方法向集合中添加元素

使用update()将一个集合中的元素添加到当前集合中
update()可以传递序列或字典作为参数，字典只会使用键。

a = set([1,'a','b',4,5]); 

b = set('helloaaaa');
a.update(b);
print(a,type(a)); # {1, 'l', 4, 5, 'o', 'h', 'b', 'e', 'a'} <class 'set'>

使用pop()函数随机删除一个集合中的元素，记住随机的不固定。

a = set([1,'a','b',4,5]); 

result = a.pop();
print(a,type(a));  # 随机删除
print(result,type(result)); # 返回值就是被删除的元素

使用remove()删除集合中的指定元素

a = set([1,'a','b',4,5]); 
a.remove('a');
print(a); # {1, 4, 5, 'b'}

使用clear()清空集合

使用copy()方法对集合进行浅复制，注意浅复制，和上面一样。

6.3 集合的运算

首先注意，集合在做运算时，不会影响原来的集合，而是返回一个新集合的运算结果。

& 交集运算
就是数学中取交集来运算。

a = set([1,'a','b',4,5]); 
b = set([1,2,3,4,5,'a']);
c = a & b;
print(c,type(c)); # {1, 4, 5, 'a'} <class 'set'>

| 并集运算
合并两个集合所有的内容。

a = set([1,'a','b',4,5]); 
b = set([1,2,3,4,5,'a']);
c = a | b;
print(c,type(c)); # {1, 'a', 2, 4, 5, 3, 'b'} <class 'set'>

- 差集运算
差集就是数学中的差集，a - b，就是a有并没有的元素。

a = set([1,'a','b',4,5]); 
b = set([1,2,3,4,5,'a']);
c = a - b;
print(c,type(c)); # {'b'} <class 'set'> 

^ 亦或集
亦或集表示不相交的部分都是，就是除了两者的并集减去交集，剩下的就是亦或集。

a = set([1,'a','b',4,5]); 
b = set([1,2,3,4,5,'a']);
c = a ^ b;
print(c,type(c)); # {2, 3, 'b'} <class 'set'>

<= 检查一个集合是否是另一个集合的子集。

下图超集的概念记一下：

最注意的地方就是两个集合相同的情况下，那么它们两个也算是彼此之间另一个子集，但不是真超集。

b = set([1,2,3]); 
a = set([1,2,3,4,5]);
result = b <= a;
print(result); # True

< 检查一个集合是否是另一个集合的真子集。

>= 检查一个集合是否是另一个的超集。

>检查一个集合是否是另一个的真超集。

其实这些符号就是对应数学那些知识没必要死机。