Python学习笔记（进阶2.0）

字典遍历

通过for ... in ...:的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构。

1、遍历字典的所有key

>>> info = {'name': 'xiaoming', 'age': 20, 'hometown': '广州'}
>>> for i in info.keys():
...     print(i)
... 
name
age
hometown
>>>

 2.遍历字典的左右value

>>> info = {'name': 'xiaoming', 'age': 20, 'hometown': '广州'}
>>> for i in info.values():
...     print(i)
... 
xiaoming
20
广州
>>>

 3.遍历字典元素

>>> info = {'name': 'xiaoming', 'age': 20, 'hometown': '广州'}
>>> for i in info.items():
...     print(i)
... 
('name', 'xiaoming')
('age', 20)
('hometown', '广州')

4、遍历字典的key-value

>>> for key,value in info.items():
...     print(key,value)
... 
name xiaoming
age 20
hometown 广州
>>>

集合

set集合，是一个无序且不重复的元素集合。

创建集合方式：

# 第一种方式
set1 = {"1","2"}
print(set1)
print(type(set1))
# 第二种方式
list1 = ['1','5','4','3']
set2 = set(list1)
print(set2)
print(type(set2))

集合常用方法

1.add添加一个元素

>>> set1 = {'1','2'}
>>> set1.add('3')
>>> set1
{'2', '1', '3'}
>>>

2.clear清空集合的元素

>>> set1
{'2', '1', '3'}
>>> 
>>> set1.clear()
>>> set1
set()
>>>

3.difference两个集合的差集，a中存在，b中不存在

>>> a = {32,12,34}
>>> b = {12,43,23}
>>> a.difference(b) #a-b
{32, 34}
>>>

差集图实例：

 4.、intersection 两个集合的交集，a中存在，b中也存在的

>>> a = {32,12,34}
>>> b = {12,43,23}
>>> a.intersection(b) #a&b
{12}
>>>

交集图实例

 5、union 并集 包含a中的元素，也包含b中的元素

>>> a = {32,12,34}
>>> b = {12,43,23}
>>> a.union(b) #a | b
{32, 34, 23, 43, 12}

并集图实例：

6.pop集合pop移除某个元素并且获取那个参数，集合pop没有参数

 

>>> a =  {32,12,34}
>>> a.pop()
32
>>> a
{34, 12}
>>>

7、discard移除指定元素

>>> a =  {32,12,34}
>>> a.discard(12)
>>> a
{32, 34}
>>>

8.update更新集合

>>> a={1,2,3}
>>> b={4,5,6}
>>> a.update(b)
>>> a
{1, 2, 3, 4, 5, 6}
>>>

数据类型共有操作

1、合并操作+，适用于字符串，列表，元组

>>> str1 = 'hello'
>>> str2 = 'world'        
>>> str1 + str2   # 字符串
'helloworld'

>>> [1,2,3] + [4,5,6]   # 列表
[1, 2, 3, 4, 5, 6]

>>> ('a','b')+('c','d')  # 元祖
('a', 'b', 'c', 'd')
>>>

2、* 复制 适用于字符串、列表、元组

>>> str1 = 'hello'
>>> str1*3
'hellohellohello'   # 字符串
>>> [1,2,3]*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]  # 列表
>>> (1,2,3)*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)  # 元祖

3.in 判断元素是否存在 适用于 字符串、列表、元组、字典、集合

>>> 'my' in 'my name is lilei'
True
>>> 1 in [1,2,3]
True
>>> 'age' in {'name':'xiaoming','age':18}
True

匿名函数（函数姿势扩展）

Python中使用lambda关键字创建匿名函数，所谓匿名即这个函数没有名字不用def关键字创建标准函数。lambda创建匿名函数

lambda 参数1,参数2,参数3: 执行代码语句

使用lambad表达式计算两个数和：

sum = lambda x,y:x +y
sum(1,3)
sum(4,5)

换成普通函数其实就是这样的

def sum(x,y):
    return x + y

2、lambda可以接收多个参数，但是只能返回一个值。要调用匿名函数得先赋值给一个变量，通过变量才能调用。

3、lambda表达式可以当一个函数值传递。

def sum(a,b,lam):
    print(a)
    print(b)
    print(lam(a,b))

a = 1
b = 2
sum(a,b,lambda x,y:x+y)


# 输出结果
#1
#2
#3

递归函数（函数知识扩展）

1、递归函数  如果一个函数在内部不调用其它函数，而是调用自己本身的话，这个函数就是递归函数。示例：求阶乘5！=5*4*3*2*1

阶乘
5！ 5*4*3*2*1
4！ 4*3*2*1
3！ 3*2*1
2！ 2*1
1！ 1

使用循环实现：

def fact(n):
    if n == 1:
        return 1
    else:
        num = 1
        while n > 1:
            num *= n 
            n -= 1
        return num

递归实现：
 

def face(n):
    if n == 1:
        return 1 
    return n * face(n-1)

2、递归函数必须有一个结束条件，否则递归无法结束会一直鬼鬼下去，直到到达最大递归深度报错。

3、递归的优缺点：

优点：

（1）递归使代码看起来更加整洁、优雅

（2）可以用递归将复杂任务分解成更加简单的子问题

（3）使用递归比使用一些嵌套迭代更简单

缺点：

（1）递归逻辑很难调试，递归条件处理不好容易造成程序无法结束，知道达到最大递归深度错误。

2、递归占用大量内存，耗费计算机资源。

数学运算

1、abs（）求绝对值，可以是整数，小数。

>>> abs(10)
10
>>> abs(-10)
10
>>> abs(-10.023)
10.023
>>>

2、round(2.6) 四舍五入取整，也就是3.0 round(2.33365,3) 四舍五入保留几位小数

>>> round(2.6)
3
>>> round(2.4)
2
>>> round(-2.4)
-2
>>> round(2.465445,3)
2.465
>>>

3、pow(2, 3) 求指数，相当于23 pow(2, 3, 5)，求指数之后再求余数，相当于2的3次幂% 5

>>> pow(2,3)
8
>>> pow(2,3,2)
0
>>> pow(2,3,4)
0
>>> pow(2,3,5)
3
>>>

4、divmod(9,3) 返回除法结果和余数

>>> divmod(7,3)
(2, 1)
>>> divmod(9,3)
(3, 0)
>>>

5、max([1,5,2,9]) 返回最大值 9、min([9,2,-4,2]) 返回最小值 -4、sum([2,-1,9,12]) 求和

>>> max([1,5,2,6])
6
>>> min([1,5,2,6])
1
>>> sum([1,6,5,3])
15

6、eval(表达式，globals = None，locals = None) 参数是一个字符串和可选的全局变量和局部变量。如果提供， globals必须是一个字典

>>> a=1
>>> b=2
>>> c =3
>>> eval('a+b')
3
>>> eval('a+b+c',{'c':3,'a':1,'b':3})
7

 类型转换

1、int("5") 转换为整数，将数字类型的字符串，浮点数，转换成整数

>>> int('666')
666
>>> int(3.6)
3

2、float(2) 转换为浮点数float，将数字型的字符串，浮点数，转换成字符串

>>> float(3)
3.0
>>> float('3')
3.0
>>>

3、str(2.3) 转换为字符串string

>>> a = 1
>>> type(a)
<class 'int'>
>>> b = str(a)
>>> type(b)
<class 'str'>
>>>

4、ord("A") 转换ASCII字符为相应的数字

>>> ord('A')
65
>>> ord('a')
97

5、chr(65) 转换数字为相应ASCII码字符

>>> chr(65)
'A'
>>> chr(66)
'B'
>>> chr(67)
'C'

6、bool(0) 转换为相应的布尔值，在Python中，0相当于False，

下列对象都相当于False： [], (), {}, 0, None, 0.0, ''

>>> bool(0)
False
>>> bool([])
False
>>> bool('a')
True
>>>

7、bin(32) 返回一个数字的二进制数。

>>> bin(52)
'0b110100'
>>> bin(12)
'0b1100'

8、hex(32) 返回一个数字的十六进制

>>> hex(32)
'0x20'
>>> hex(63)
'0x3f'

9、oct(56) 返回一个数字的八进制

>>> oct(56)
'0o70'
>>> oct(9)
'0o11'
>>> oct(8)
'0o10'
>>>

10、list((1,2,3)) 转换为表 list,可以将一个可迭代对象转成列表

>>> list((1,2,3))
[1, 2, 3]

>>>

11、tuple([2,3,4]) 转换为定值表 tuple

>>> tuple([2,3,4]) 
(2, 3, 4)
>>> tuple({'a':1,"b":2})
('b', 'a')
>>>

12、dict(a=1,b="hello",c=[1,2,3]) 构造字典dictionary

>>> dict(a=1,b="hello",c=[1,2,3])
{'b': 'hello', 'a': 1, 'c': [1, 2, 3]}
>>>

13、bytes 返回一个字节对象

>>> bytes('中'.encode('utf-8'))
b'\xe4\xb8\xad'
>>> bytes('中'.encode('gbk'))
b'\xd6\xd0'
>>>