author: UpDown published: True created: 2022年5月10日08点37分 tags: Done version: Outer

注释

• 单行：#

• 多行：

  '''
  注释
  '''

  版本中文支持

  python3中，是默认支持中文的，但是在python2中就需要一定的额外操作才可以
  解决的办法为：在程序的开头写入如下代码，这就是中文注释
  #coding=utf-8
  在python的语法规范中推荐使用的方式：
  # -*- coding:utf-8 -*-

  变量

  怎样知道一个变量的类型呢？

• 在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别

• 可以使用type(变量的名字)，来查看变量的类型

  标识符

  标识符由字母、下划线和数字组成，且数字不能开头
  python中的标识符是区分大小写的

  命名规则

• 小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog

• 大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName
• 还有一种命名法是用下划线“_”来连接所有的单词，比如send_buf

  Python的命令规则遵循PEP8标准，这个在后面会慢慢讲到。 PEP8规范：https://zhuanlan.zhihu.com/p/110405756

#1、变量、函数和属性应该使用小写字母来拼写，如果有多个单词就使用下划线进行连接。
#2、类中受保护的实例属性，应该以一个下划线开头。
#3、类中私有的实例属性，应该以两个下划线开头。
#4、类和异常的命名，应该每个单词首字母大写。
#5、模块级别的常量，应该采用全大写字母，如果有多个单词就用下划线进行连接。
#6、类的实例方法，应该把第一个参数命名为self以表示对象自身。
#7、类的类方法，应该把第一个参数命名为cls以表示该类自身。

私有化

• xx: 公有变量
• _x: 可以访问，但是不要轻易访问。按照约定俗成，当你看到这样的变量时，意思就是，“虽然我可以被访问，但请把我视为私有变量，不要随意访问。在导入的时候，from somemodule import *无法导入
• __xx：私有属性，双前置下划线，无法在外部直接访问(名字重整所以访问不到)
• xx:双前后下划线,用户名字空间的魔法对象或属性。例如:init , __ 不要自己发明这样的名字
• xx_:单后置下划线,用于避免与Python关键词的冲突
• 父类中属性名为__名字的，子类不继承，子类不能访问
• 如果在子类中向__名字赋值，那么会在子类中定义的一个与父类相同名字的属性
• _名的变量、函数、类在使用from xxx import *时都不会被导入

  print输出

  print函数的格式控制：https://zhuanlan.zhihu.com/p/137534148

1. 字符串连接法
2. format匹配法
   1. **print**("a的值为:{} b的值为:{} c的值为:{}"**.**format(a,b,c))
   2. 高级语法
      1. **print** ("a的值为:{:4d} b的值为:{:4d} c的值为:{:4d}"**.**format(a,b,c))

3. c语言风格的输出

   • print("我今年%d岁" % age)
   • print(“我的姓名是%s, 年龄是%d” % (name, age))

     完全格式符号：https://blog.updown.world/articles/python/pythonbook/file/1/section.6.html

4. f 格式化字符串

   print(f"nmb,{sb}") 高级语法：https://blog.csdn.net/ljr_123/article/details/119831860

\n换行输出

input

password = input('请输入你的密码')
注意input() 输入的数据 都是字符串类型

运算符

https://blog.updown.world/articles/python/pythonbook/file/1/section.7.html

下面以a=10 ,b=20为例进行计算

下图来源：https://blog.updown.world/articles/python/pythonbook/file/3/section.11.3.html

复合赋值运算符

如：

数据类型转换

完全表：https://blog.updown.world/articles/python/pythonbook/file/1/section.10.html

比较(关系)运算符

==，!=，>等

逻辑运算符

and,or,not

if判断

    if 条件一成立：
       执行语句...
    elif 条件二成立：
        执行语句...
    elif 条件二成立：
        执行语句...
    elif 条件二成立：
        执行语句...
    else:
        执行语句...

while循环

   while 条件:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...

i = 0
while i < 10000:
    print("WDNMD")
        i += 1

案例：九九乘法表：

i = 1
while i<=9:
    j=1
    while j<=i:
        print("%d*%d=%-2d " % (j, i, i*j), end = '')
        j+=1
    print('\n')
    i+=1

案例：倒三角

i = 1
while i <= 5:
    j = 1
    while j <= i:
        print("* ", end = '')
        j += 1

    print("\n")
    i += 1

*
* *
* * *
* * * *
* * * * *

```
<a name="q8Xad"></a>
### for循环
在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。
```python
for 临时变量 in 列表或者字符串等可迭代对象:
    循环满足条件时执行的代码

range(5)

for i in range(5):
    print(i)

break/continue

• break的作用：立刻结束break所在的循环

• continue的作用：用来结束本次循环，紧接着执行下一次的循环，相当于跳过了当前这次循环

• break/continue只能用在循环中，除此以外不能单独使用

• break/continue在嵌套循环中，只对最近的一层循环起作用

  字符串

• 双引号或者单引号中的数据，就是字符串

  下标

  列表与元组支持下标索引好理解，字符串实际上就是字符的数组，所以也支持下标索引

  方法

  字符串方法

  https://blog.updown.world/articles/python/pythonbook/file/3/section.4.2.html

find

检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
mystr.find(str, start=0, end=len(mystr)) # 方法介绍

mystr = 'hello world halon and halonge'
pos1 = mystr.find('halon')
print(pos1)  # 12

index

跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
mystr.index(str, start=0, end=len(mystr))

count

返回 str在start和end之间 在 mystr里面出现的次数
mystr.count(str, start=0, end=len(mystr))

str01 = 'hello world hello world'
# 获取字符串'o'在str01里的次数
count01 = str01.count('o')
print(count01)  # 4
# 获取字符串'hello'在str01里的次数
count02 = str01.count('hello')
print(count02)  # 2

replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
mystr.replace(str1, str2, count)

str01 = 'hello world xiaoming and xiaoming'
# 把字符串str01里的xiaoming 变成xiaohong,最后结果赋值给str02
str02 = str01.replace('xiaoming', 'xiaohong')
# 注意 原字符串str01是不变的
print(str01)  # hello world xiaoming and xiaoming
print(str02)  # hello world xiaohong and xiaohong

split

以 seq为分隔符对字符串mystr分隔，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串, 最后的结果存放到列表里
mystr.split(seq, maxsplit)

str01 = '2018-01-01'
# 用指定字符串 把str01 拆分成多个数据，存放到一个数组里
list01 = str01.split('-')
# 注意原字符串str01 不会改变
print(str01)  # 2018-01-01
print(list01) # ['2018', '01', '01']

如果split不指定分隔符，那么默认就是用空格分隔，如下

str01 = 'hello ha ha he he   world\t python'
list01 = str01.split() 
print(list01) # ['hello', 'ha', 'ha', 'he', 'he', 'world', 'python']

注意如果分隔符在字符串左侧或者右侧，结果会多出空字符串，效果如下

str01 = 'hello ha ha he he'
list01 = str01.split('he')
print(list01)  # ['', 'llo ha ha ', ' ', '']

可以指定分隔的次数 如下

str01 = '2018-01-02-03-04'
# 只分隔前两次的分隔符
list01 = str01.split('-',2)
print(list01)  # ['2018', '01', '02-03-04']

join

mystr 中每个元素后面插入str,构造出一个新的字符串
mystr.join()

str01 = '-'
list01 = ['hello', 'world', 'python', 'is', 'good']
str02 = str01.join(list01)
print(str02) # hello-world-python-is-good

encode

str.encode(encoding='utf-8', errors="strict")
其中的encoding是指在解码编码过程中使用的编码(此处指“编码方案”是名词)，errors是指错误的处理方案

decode

同上

其余方法

• capitalize：把字符串的第一个字符大写
• title： 把字符串的每个单词首字母大写
• startswith：检查字符串是否是以 hello 开头, 是则返回 True，否则返回 False
  • print(str01.startswith('hello')) # True
• endswith：检查字符串是否以obj结束，如果是返回True,否则返回 False.
• lower：转换所有大写字符为小写
• upper： 转换的小写字母为大写

• ljust: 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

  • mystr.ljust(width)

    str01 = 'hello'
    str02 = str01.ljust(10)
    # 注意效果 end指定的字符串的位置
    print(str02, end='-')  # 'hello     -'
    

• rjust: 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

• center: 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
• lstrip: 删除 mystr 左边的空白字符
  • mystr.lstrip()
• rstrip: 删除 mystr 字符串末尾的空白字符
• strip：删除mystr字符串两端的空白字符（包括\n\t）
• rfind: 类似于 find()函数，不过是从右边开始查找
• rindex: 类似于 index()，不过是从右边开始

• partition: 把mystr以str分割成三部分,str前，str和str后

  • mystr.partition(str)

    str01 = 'hello world halon and halonge'
    t1 = str01.partition('halon')
    print(t1)  # ('hello world ', 'halon', ' and halonge')
    

• rpartition: 类似于 partition()函数,不过是从右边开始.

• splitlines: 按照行分隔，返回一个包含各行作为元素的列表

  • mystr.splitlines()

    str01 = 'hello\nworld'
    print(str01)
    str02 = str01.splitlines()
    print(str02)
    

• isalpha: 如果 mystr 所有字符都是字母 则返回 True,否则返回 False

• isdigit: 如果 mystr 只包含数字则返回 True 否则返回 False.
• isalnum: 如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
• isspace: 如果 mystr 中只包含空格，则返回 True，否则返回 False.

切片

各种语法：https://blog.updown.world/articles/python/pythonbook/file/3/section.4.html

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]
注意：选取的区间从”起始”位开始，到”结束”位的前一位结束（不包含结束位本身)，步长表示选取间隔。

反切：print(a[6:0:-2]) # 步长是负数 从右向左取 注意起始下标和结束下标也要从右向左

列表

与c语言不同，python列表中的元素可以是不同类型的

    namesList = ['xiaoWang','xiaoZhang','xiaoHua']
    print(namesList[0])

for循环列表

names = ["张三", "李四", "王六", 'halon', '小马哥']
for name in names:
    print(name)
'''
    张三
    李四
    王六
    halon
    小马哥
'''

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

A[1] = 'xiaoLu'

查找元素

in, not in

• in（存在）,如果存在那么结果为true，否则为false
• not in（不存在），如果不存在那么结果为true，否则false

if findName in nameList:

列表操作

append

通过append可以向列表添加元素
names.append('nmb')

extend

通过extend可以将另一个集合中的元素逐一添加到列表中

list01 = [1, 2]
list02 = [3, 4]
list01.append(list02)
print('append效果---查看list01----%s' % list01)

list01.extend(list02)
print('extend效果---查看list01----%s' % list01)
"""
append效果---查看list01----[1, 2, [3, 4]]
extend效果---查看list01----[1, 2, [3, 4], 3, 4]
"""

insert

insert(index, object) 在指定位置index前插入元素object

list01 = [0, 1, 2, 3, 4]
# 在列表的索引为一的位置 添加一个元素
list01.insert(1, 3)
# 打印输出添加后的效果
print(list01) # 结果是 [0, 3, 1, 2, 3, 4]

index, count

index和count与字符串中的用法相同

del

根据下标进行删除
del movieName[2]
del VS delattr()

https://vimsky.com/examples/usage/delattr-del-python.html

1. 动态删除：del是更明确和有效的，并且delattr()允许动态属性删除。
2. Speed:如果考虑并运行以上程序，则执行速度之间会有细微差别。与delattr()相比，del稍快一些，具体取决于机器。
3. 字节码说明：与delattr()相比，del还占用更少的字节码指令。

因此，我们通过说del比delattr快一点来结束比较，但是当涉及到属性的动态删除时，delattr()具有优势，因为del运算符无法实现。

pop

删除最后一个元素
movieName.pop()

remove

根据元素的值进行删除
movieName.remove('指环王')

sort

方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
a.sort()
a.sort(reverse=True)

reverse

是将list逆置。
a.reverse()

元组

不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
aTuple = ('et',77,99.9)
tuple[0]获取元组中的元素

count, index

index和count与字符串和列表中的用法相同

字典

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

• 字典的每个元素由2部分组成，键:值。例如 ‘name’:’班长’ ,’name’为键，’班长’为值

• info['name']通过键访问值

  • 若访问不存在的键，则会报错：

    get

• 在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：

  >>> age = info.get('age')
  >>> age #'age'键不存在，所以age为None
  >>> type(age)
  <type 'NoneType'>
  >>> age = info.get('age', 18) # 若info中不存在'age'这个键，就返回默认值18
  >>> age
  18
  

  字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
  info['id'] = int(new_id)
  如果在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素。

  in

  in在对字典操作时，判断的是字典的键

  >>> 'itc' in 'hello itcast'
  True
  >>> 3 in [1, 2]
  False
  >>> 4 in (1, 2, 3, 4)
  True
  >>> "name" in {"name":"Delron", "age":24}
  True
  

  遍历

  通过for … in … 我们可以遍历字符串、列表、元组、字典等 ```python dict01 = {‘name’: ‘张三’, ‘age’: 18, ‘sex’: ‘m’} for key in dict01.keys(): print(key)

结果： name age sex

```python
dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
for key, value in dict01.items():
    print('%s--%s' % (key, value))

结果：
name--张三
age--18
sex--m

字典操作

del

del info['name']: 删除指定的元素
del info: 删除整个字典

clear

info.clear()
清空整个字典

len()

测量字典中，键值对的个数

keys

返回一个包含字典所有KEY的列表

dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
keys = dict01.keys()
print(keys)   # ['name', 'age', 'sex']

values

返回一个包含字典所有value的列表

dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
values = dict01.values()
print(values)  # ['张三', 18, 'm']

items

返回一个包含所有（键，值）元祖的列表

dict01 = {'name': '张三', 'age': 18, 'sex': 'm'}
items = dict01.items()
print(items) # [('name', '张三'), ('age', 18), ('sex', 'm')]

enumerate()

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>> chars = ['a', 'b', 'c', 'd']
>>> for i, chr in enumerate(chars):
...     print("%d %s"%(i, chr))
...
0 a
1 b
2 c
3 d

内置函数(内建函数)

cmp

>>> cmp("hello", "itcast")
-1
>>> cmp("itcast", "hello")
1
>>> cmp("itcast", "itcast")
0
>>> cmp([1, 2], [3, 4])
-1
>>> cmp([1, 2], [1, 1])
1
>>> cmp([1, 2], [1, 2, 3])
-1
>>> cmp({"a":1}, {"b":1})
-1
>>> cmp({"a":2}, {"a":1})
1
>>> cmp({"a":2}, {"a":2, "b":1})
-1

注意：cmp在比较字典数据时，先比较键，再比较值。

len

>>> len("hello itcast")
12
>>> len([1, 2, 3, 4])
4
>>> len((3,4))
2
>>> len({"a":1, "b":2})
2

注意：len在操作字典数据时，返回的是键值对个数。

max

>>> max("hello itcast")
't'
>>> max([1,4,522,3,4])
522
>>> max({"a":1, "b":2})
'b'
>>> max({"a":10, "b":2})
'b'
>>> max({"c":10, "b":2})
'c'

del

del有两种用法，一种是del加空格，另一种是del()

>>> a = 1
>>> a
1
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> a = ['a', 'b']
>>> del a[0]
>>> a
['b']
>>> del(a)
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

map

map函数会根据提供的函数对指定序列做映射

a = map(lambda x: x*x, [1, 2, 3])
b = map(lambda x, y: x+y, [1, 2, 3], [4, 5, 6])# 多参数的情况
# for i in b:
    # print(i)
for i in a:
    print(i)
print(b)
print(a)
"""
1
4
9
<map object at 0x0000028474BD3E50>
<map object at 0x0000028474BD3EE0>
"""

将lambda改为普通函数
与之前的1个案例，很类似，仅仅是将函数由之前使用的匿名函数改为了def定义的函数而已，其他运行过冲没有差异

def f1( x, y ):  
    return (x,y)

l1 = [ 0, 1, 2, 3, 4, 5, 6 ]  
l2 = [ 'Sun', 'M', 'T', 'W', 'T', 'F', 'S' ]
l3 = map( f1, l1, l2 ) 
print(list(l3))
# 结果为:[(0, 'Sun'), (1, 'M'), (2, 'T'), (3, 'W'), (4, 'T'), (5, 'F'), (6, 'S')]

filter

filter函数会对指定序列执行过滤操作

• function:接受一个参数，返回布尔值True或False
• sequence:序列可以是str，tuple，list等 ```python filter(lambda x: x%2, [1, 2, 3, 4])

  [1, 3]

filter(None, “she”)

‘she’

<a name="xdwol"></a>
#### reduce
reduce函数会对参数序列中元素进行重复操作<br />reduce函数依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function<br />在Python3里, reduce函数已经被放置在fucntools模块里用的话要先引入： from functools import reduce
```python
reduce(lambda x, y: x+y, [1,2,3,4])
10

reduce(lambda x, y: x+y, [1,2,3,4], 5)
15

reduce(lambda x, y: x+y, ['aa', 'bb', 'cc'], 'dd')
'ddaabbcc'

函数

来源：https://blog.updown.world/articles/python/pythonbook/file/4/README-2.html

def 函数名():
    代码

函数名() # 调用

• 每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了
• 当然了如果函数中执行到了return也会结束函数

  函数文档

  ```python def sum_2_num(a, b): “”” 求两个数的和 :param a:参数一 :param b:参数二 :return:返回result 两个数的和 “”” result = a + b return result

sum_2_num(2,3)

`help(sum_2_num)`
<a name="mZgiv"></a>
#### 传参

- 定义时小括号中的参数，用来接收参数用的，称为 “形参”
- 调用时小括号中的参数，用来传递给函数用的，称为 “实参”
1. 位置参数 : `def print_info(name, age):`
1. 可变参数(不定长参数):`def sum_nums(a, b, c=0, *args):`
- 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
```python
def sum_nums(a, b, c=0, *args):
    result = a+b+c
    print("-"*10)
    print(a)
    print(b)
    print(c)
    print(args)
    print(result)


sum_nums(11, 22)
sum_nums(11, 22, 33)

1. 关键字参数（**kwargs）

• 变量**kwarg会存放key=value的参数， kwargs为字典.
• 变量kwarg必须放在所有参数的最右侧 ```python def sum_nums(a, b=11, c=22, *args, kwargs): print(a) print(b) print(c) print(args) print(kwargs)

sum_nums(100, 200, 300, 400, 500, 600, d=3.14, age=18)

“”” 100 200 300 (400, 500, 600) {‘d’: 3.14, ‘age’: 18} “””

- `def print_info(name, age=18):`在形参中默认有值的参数，称之为缺省参数
- **注意：缺省参数一定要位于位置参数的后面**
- 缺省参数在*args后面`def sum_nums_3(a, *args, b=22, c=33):`
- <br />
<a name="Mj1aj"></a>
#### 作用域

- 局部变量，就是在函数内部定义的变量
- 其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
- 当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了
<a name="SzsIN"></a>
#### 全局变量和局部变量名字相同问题

- 如果在函数中出现global 全局变量的名字 那么这个函数中即使出现和全局变量名相同的变量名 = 数据 也理解为对全局变量进行修改，而不是定义局部变量
- 如果在一个函数中需要对多个全局变量进行修改，那么可以使用
```python
def fucku():     
    # 可以使用一次global对多个全局变量进行声明
     global a, b
     # 还可以用多次global声明都是可以的
     # global a
     # global b

多个return

• 一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处

• 如果程序设计为如下，是可以的因为不同的场景下执行不同的return

  一个函数返回多个数据的方式

  https://blog.updown.world/articles/python/pythonbook/file/4/section.8.4.html

• return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据

• 如果return后面有多个数据，那么默认是元组

多个数据逗号分隔，默认是元组

m = 1, 2, 3
print(m)  # (1, 2, 3)

返回的数据直接拆包

• 拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常
• 除了对元组拆包之外，还可以对列表、字典等拆包 ```python def get_my_info(): high = 178 weight = 100 age = 18 return high, weight, age

result = get_my_info()

print(result)

my_high, my_weight, my_age = get_my_info() print(my_high) print(my_weight) print(my_age)

```python
# a, b = (11, 22)
a, b = 11, 22
print(a)
print(b)

a, b = [11, 22]
print(a)
print(b)

a, b = {"m": 11, "n": 22}  # 取出来的是key，而不是键值对
print(a) #m
print(b) #n

引用当做实参

• Python中函数参数是引用传递（注意不是值传递）
• 对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
• 而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量 ```python def test1(b): # 变量b一定是一个局部变量，就看它指向的是谁？可变还是不可变 b += b # += 是直接对b指向的空间进行修改,而不是让b指向一个新的

  b = b+b # xx = xx+yyy 先把=号右边的结果计算出来,然后让b指向这个新的地方,不管原来b指向谁

            # 现在b一定指向这个新的地方
  

a = [11, 22]

a = 100 test1(a) print(a)

<a name="Ynolj"></a>
### function.__name__
获取函数名
```python
def sb():
    pass

print(sb.__name__) # sb

交换2个变量的值

# 第4种方式
a, b = 4, 5
a, b = b, a

id

id(a)
在python中，值是靠引用来传递来的

>>> a = 1
>>> b = a
>>> id(a) 
13033816
>>> id(b)   # 注意两个变量的id值相同
13033816

可变、不可变类型

• 所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变
• 可变类型有： 列表、字典、集合

• 不可变类型有： 数字、字符串、元组

  eval()函数

  可以传入指定字符串作为参数，如果字符串里是一个有效的表达式，就会被执行

  a = 10
  str01 = 'a + 20'
  print(str01)
  print(eval(str01))  # 'a+20'  ----->   a+20
  

  把字符串转成对应的类型

  str01 = '123'
  num1 = int(str01)
  print(type(num1))
  print(num1)
  

• 还可以用eval来实现

  num2 = eval(str01)
  print(type(num2))
  print(num2)
  

  lambda 匿名函数

  用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
  Lambda函数能接收任何数量的参数但只能返回一个表达式的值
  匿名函数不能直接调用print，因为lambda需要一个表达式 ```python sum = lambda arg1, arg2: arg1 + arg2

调用sum函数

print(“Value of total : “ % sum( 10, 20 )) print(“Value of total : “% sum( 20, 20 ))

<a name="hYen0"></a>
#### 应用场景

1. 自己定义函数
```python
>>> def fun(a, b, opt):
...     print("a = " % a)
...     print("b = " % b)
...     print("result =" % opt(a, b))
...
>>> fun(1, 2, lambda x,y:x+y)
a = 1
b = 2
result = 3

1. 作为内置函数的参数

   数组中对象排序

   ```python stus = [ {“name”: “zhangsan”, “age”: 18}, {“name”: “lisi”, “age”: 19}, {“name”: “wangwu”, “age”: 17} ]

按name排序：

stus.sort(key = lambda x: x[‘name’]) stus [{‘age’: 19, ‘name’: ‘lisi’}, {‘age’: 17, ‘name’: ‘wangwu’}, {‘age’: 18, ‘name’: ‘zhangsan’}]

按age排序：

stus.sort(key = lambda x: x[‘age’]) stus [{‘age’: 17, ‘name’: ‘wangwu’}, {‘age’: 18, ‘name’: ‘zhangsan’}, {‘age’: 19, ‘name’: ‘lisi’}] ```

sys

给程序传参数 ```python import sys

print(sys.argv)

<a name="IScdX"></a>
### range
python中 range() 函数可创建一个整数列表，一般用在 for 循环中

- **注意：range函数在python2和python3中有些区别**
- 在python2返回的是一个列表在python3中返回的是一个**迭代器** ，大家可以当做一个列表来使用，关于迭代器后面高级知识中讲解
```python
range(start, stop[, step])

start: 计数从 start 开始。默认是从 0 开始
stop: 计数到 stop 结束，但不包括 stop
step：步长，默认为1

>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(2,9)
[2, 3, 4, 5, 6, 7, 8]
>>> range(10) # 如果从0开始 那么0可以省略
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0,20,3)   #注意步长
[0, 3, 6, 9, 12, 15, 18]
>>> range(0,30,5)   #注意步长
[0, 5, 10, 15, 20, 25]

负数也可以，注意：如果 如果开始比结束的数字小，那么步长也要是负值

>>> range(5,-10,-1)
[5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0,-20,-3)
[0, -3, -6, -9, -12, -15, -18]

list01 = [0, 1, 2, 3, 4, 5]
# 遍历列表
for item in list01:
    print(item)

print('-------------------')
# 也可以这样
for item in range(0, 6):
    print(item)

列表推导式

所谓的列表推导式，就是指的轻量级循环创建列表

多个for循环

set 集合

s01 = {1, 2, 3, 4, 5}
print(type(s01))

1. 怎么创建空集合 ```python s01 = {} print(type(s01)) # 字典

s02 = {1, 2, 3} print(type(s02)) # 集合

创建空的集合

s03 = set() print(type(s03))

2. 不允许元素重复
<a name="qo52I"></a>
#### set、list、tuple之间可以相互转换
```python
# 定义一个列表
list01 = [11, 22, 33, 55, 77]

# 列表转元组
t01 = tuple(list01)
print(t01)

# 列表转集合
s01 = set(list01)
print(s01)

# 元组转集合
s01 = set(t01)
print(s01)
# 集合转列表
list02 = list(s01)
print(list02)

使用set，可以快速的完成对list中的元素去重复的功能

list01 = [11, 4, 22, 3, 33, 55, 6, 77, 22, 55, 11, 3]

s01 = set(list01)
print(s01)  # {33, 3, 4, 6, 11, 77, 22, 55}