python 人生苦短,我学Python

Posted IT_Holmes

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python 人生苦短,我学Python相关的知识,希望对你有一定的参考价值。

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

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

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

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

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

以上是关于python 人生苦短,我学Python的主要内容,如果未能解决你的问题,请参考以下文章

人生苦短,我学python

人生苦短,我学Python

人生苦短,我学python

人生苦短,我学python之python MD5加密

人生苦短,我学python之python xml数据解析

python 人生苦短,我学Python