python 优秀的语法糖及需要记录备忘的内容（持续更新...）
登录
标签搜索
侧边栏壁纸
博主昵称
Elysian

  • 累计撰写 74 篇文章
  • 累计收到 0 条评论
python

python 优秀的语法糖及需要记录备忘的内容（持续更新...）

Elysian
Elysian
2022-09-28 / 0 评论 / 136 阅读 / 正在检测是否收录...

python3 入门知识（难点、语法糖、备忘）内容

循环中的else

一、while...else...

1. 格式

while 条件:
    # 条件满足时执行的代码...
else:
    # 如果上述的while循环没有调用break，就执行的代码...

说明：

  • 只要while循环体中没有执行break，那么当while循环体中所有的代码执行完后，else中的代码也会执行
  • 如果while循环中有break那么表示整个while介绍，else中的代码也不会被执行

2. 示例

有break时
i = 1
while i <= 3:
    print("哈哈，我是超神，double kill......")
    if i == 1:
        print("调用了break")
        break
    i += 1
else:
    print("我是else中的代码")

运行结果

哈哈，我是超神，double kill......
调用了break
没有break时
i = 1
while i <= 3:
    print("哈哈，我是超神，double kill......")
    i += 1
else:
    print("我是else中的代码")

运行结果

哈哈，我是超神，double kill......
哈哈，我是超神，double kill......
哈哈，我是超神，double kill......
我是else中的代码

3. 案例

i = 3
while i > 0:
    password = input("请输入密码：（还剩%d次机会）" % i)
    if password == "123456":
        print("密码输入正确")
        break
    i -= 1
else:
    print("密码输入3次全部错误，请明日再试")

三、for...else...

1. 格式

for 变量 in 可迭代对对象:
    # 正常执行的代码
else:
    # for未使用break时执行的代码

2. 示例

未使用break
for i in range(5):
    print("i=%d" % i)
else:
    print("我是else中的代码...")

运行结果：

i=0
i=1
i=2
i=3
i=4
我是else中的代码....
使用break
for i in range(5):
    print("i=%d" % i)
    if i == 1:
        print("我是break哦...")
        break
else:
    print("我是else中的代码...")

运行结果：

i=0
i=1
我是break哦...

3. 案例

for i in range(3, 0, -1):
    password = input("请输入密码：（还剩%d次机会）" % i)
    if password == "123456":
        print("密码输入正确")
        break
else:
    print("密码输入3次全部错误，请明日再试")

字符串切片

一、是什么

较为官方的说法：切片是指对操作的对象截取其中一部分的操作

通俗来说：一种能够从数据中取到一部分数据的方式

例如，

有一个字符串"abcdef"，我们可以通过切片取到"cde"

切片不仅可以在字符串中应用，还可以对列表、元组等进行操作，简言之“切片”功能很重要。

本节课我们以字符串为例讲解“切片”

二、怎样用

1. 语法

[起始:结束:步长]
注意
  • 选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔
  • 默认“步长”为1，即取完一个下标的数据之后，第二个下标的是在刚刚下标基础上+1
  • 步长为正数，表示从左向右取数据
  • 步长为负数，表示从右向左取数据

2. 示例

demo1
name = 'abcdef'
print(name[0:3])  # 取下标为0、1、2的字符，注意取不到下标为3的空间

运行结果:

abc

推导式

一、是什么

推导式：就是一种能够快速生成数据的方式

例如，想要快速生成由1~20内所有奇数数组成的列表，就可以用"推导式"，代码如下

[x for x in range(1, 21) if x % 2 == 0]

运行结果如下:

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

二、分类

推导式，根据最终要生成的数据，简单划分为

  • 列表推导式
  • 集合推导式
  • 字典推导式

注意：

没有元组推导式，而是生成器（在Python高级进阶课程中在学习）

三、列表推导式

列表推导式：一种可以快速生成列表的方式

1. 格式

[变量 for 变量 in 可迭代对象]

四、集合推导式

集合推导式：一种快速生成集合的方式

示例：

In [5]: a = {x for x in range(1, 21) if x % 2 == 0}

In [6]: type(a)
Out[6]: set

In [7]: a
Out[7]: {2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

集合推导式中也可以用if等，与列表推导式在格式上很类似，这里就不做过多的介绍，请类别列表推导式进行学习

五、字典推导式

字典推导式：一种快速生成字典的方式

示例1:

快速生成一个1~10内key为某个数此时value为平方的字典

{x:x**2 for x in range(1, 11)}

拆包

一、是什么

拆包：是一种快速提取数据的方式

例如，有一个元组(11, 22, 33, 44)想快速的提取每个元素且赋值给num1, num2, num3, num4这4个变量

普通的做法，较为繁琐

nums = (11, 22, 33, 44)  # 定义一个元组
num1 = nums[0]  # 通过下标来提取
num2 = nums[1]  # 通过下标来提取
num3 = nums[2]  # 通过下标来提取
num4 = nums[3]  # 通过下标来提取

拆包的方式，可以见非常简洁

num1, num2, num3, num4 = (11, 22, 33, 44)  # 一行代码搞定

二、拆列表

示例

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

运行结果：

11
22

三、拆元组

示例

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

运行结果：

11
22

四、拆集合

示例

a, b = {11, 22}
print(a)
print(b)

运行结果：

11
22

五、拆字典

1. 一般用法

示例

a, b = {"name": "王老师", "web_site": "http://www.codetutor.top"}
print(a)
print(b)

运行结果：

name
web_site

默认取到的是字典的key，而不是value

六、注意点

=右边要拆的数据元素的个数 要 与=左边存的变量个数相同

错误示例如下：

a, b = [11, 22, 33]

函数参数高级用法

一、缺省参数

1. 是什么

缺省参数也叫做默认参数，是指定义函数时形参变量有默认值，如果调用函数时没有传递参数，那么函数就用默认值，如果传递了参数就用传递的那个数据

2. 做什么

当调用函数时，有些参数不必传递，而是用默认值，这样的场景往往都用缺省参数

例如，一个学校现在开始检查每个学生的信息，学生说：报告老师我是xxx学校xxx系xxx年级xxx班学生，名字叫xxxx，大家想只要是这学校的学生那么“xxx学校”就可以省略不用说了，因为大家都知道。所以就可以认为默认的学校就是xxx，而当其他学校的学生介绍时yyy学校名字案例说就一定要说清楚，否则让人弄混了

来个demo试试看

def print_info(name, class_name, grade, department_name, school_name="通俗易懂"):
    print("老师好：我是来自 %s学校 %s系 %s年级 %s班级 的学生，我叫%s" % (
        school_name,
        department_name,
        grade,
        class_name,
        name
    ))


print_info("dong", "超牛", "二", "软件工程")
print_info("dong", "超牛", "二", "软件工程", "codetutor.top")

运行结果

老师好：我是来自 通俗易懂学校 软件工程系 二年级 超牛班级 的学生，我叫dong
老师好：我是来自 codetutor.top学校 软件工程系 二年级 超牛班级 的学生，我叫dong

3. 注意点

  • 缺省参数只能在形参的最后（即最后侧）
  • 缺省参数全挨在一起（在右侧），不是缺省参数挨在一起（在左侧）
>>> def printinfo(name, age=35, sex):
...     print name
...
File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

二、命名参数

1. 是什么

命名参数是指：在调用函数时，传递的实参带有名字，这样的参数叫做命名参数

2. 做什么

命名参数能够在调用函数的时候，不受位置的影响，可以给需要的参数指定传递数据

3. 注意点

  • 命名参数的名字要与形参中的名字相同，不能出现命名参数名字叫做num，而形参中没有变量num
  • 如果形参左侧有普通的形参，调用函数时传递的参数一定要先满足这些形参，然后再根据需要编写命名参数
def test(a, b, c=100, d=200):
    print("a=%d, b=%d, c=%d, d=%d" % (a, b, c, d))


# 下面的方式都成功
test(11, 22)
test(11, 22, 33)
test(11, 22, 33, 44)
test(11, 22, d=33, c=44)

# 下面的方式都失败
test(c=1, d=2)  # 缺少a、b的值
test(c=1, d=2, 11, 22)  # 11, 22应该在左侧

三、不定长参数

1. 是什么

不定长参数：定义函数的时候形参可以不确定到底多少个，这样的参数就叫做不定长参数

不定长参数有2种方式表示

  • *args ：表示调用函数时多余的未命名参数都会以元组的方式存储到args中
  • **kwargs：表示调用函数时多余的命名参数都会以键值对的方式存储到kwargs中

注意：

  • *和**是必须要写的，否则就变成了普通的形参了
  • 当我们说不定长参数的时候，就是指*args和**kwargs

2. 做什么

通过不定长参数，能够实现调用函数时传递实参个数可以随意变换的需求

例如

def test(a, b, *args, **kwargs):
    print("-------------------------------")
    print(a, type(a))
    print(b, type(b))
    print(args, type(args))
    print(kwargs, type(args))


test(11, 22)
test(11, 22, 33, 44, 55, 66)
test(11, 22, 33, 44, 55, 66, name="wanglaoshi", web_site="http://www.codetutor.top")

运行结果：

-------------------------------
11 <class 'int'>
22 <class 'int'>
() <class 'tuple'>
{} <class 'tuple'>
-------------------------------
11 <class 'int'>
22 <class 'int'>
(33, 44, 55, 66) <class 'tuple'>
{} <class 'tuple'>
-------------------------------
11 <class 'int'>
22 <class 'int'>
(33, 44, 55, 66) <class 'tuple'>
{'name': 'wanglaoshi', 'web_site': 'http://www.codetutor.top'} <class 'tuple'>

3. 注意点

  • 加了星号*的变量args会存放所有未命名的变量参数，args为元组
  • 而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典
  • 一般情况下*args、**kwargs会在形参的最右侧
  • args与kwargs的名字可以变，例如叫*aa，**bb都是可以，但一般为了能够让其他的开发者快速读懂我们的代码最好还是不改

4. 特殊情况

缺省参数在*args后面

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)


sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)

说明：

  • *args后可以有缺省参数，想要给这些缺省参数在调用时传递参数，需要用命名参数传递，否则多余的未命名参数都会给args
  • 如果有**kwargs的话，**kwargs必须是最后的

通过*、**拆包

一、引入

假如有函数

def test(a, b, c):
    print(a + b + c)

现在自己拥有的数据

nums = [11, 22, 33]

怎样养才能在调用test函数的时候，将nums给传递过去呢?

def test(a, b, c):
    print(a + b + c)


nums = [11, 22, 33]
test(nums[0], nums[1], nums[2])

上述代码用的方式虽然能行，但不是很简洁

为了能够用更加简洁的方式实现上述场景需求，Python可以通过*、**将数据拆包后传递

二、使用*拆包

有时在调用函数时，这个函数需要的是多个参数，而自己拥有的是一个列表或者集合这样的数据，此时就用可以用*拆包

使用方式

*列表
*元组
*集合

用*拆包的方式实现上述功能

def test(a, b, c):
    print(a + b + c)


nums = [11, 22, 33]
test(*nums)  # 此时的*的作用就是拆包，此时*nums相当于11, 22, 33 即test(11, 22, 33)

当是元组时依然可以拆

def test(a, b, c):
    print(a + b + c)


nums = (11, 22, 33)
test(*nums)

当时集合是也是可以拆的

def test(a, b, c):
    print(a + b + c)


nums = {11, 22, 33}
test(*nums)

注意：

  • *对列表、元组、集合可以拆包，但一般都是在调用函数时用

三、使用**拆包

使用**可以对字典进行拆包，拆包的结果是命名参数

例如

def test(name, web_site, age):
    print(name)
    print(web_site)
    print(age)


info = {
    "name": "王老师",
    "web_site": "www.codetutor.top",
    "age": 18
}

test(**info)

四、难点

1. 疑惑点

学习不定长参数时，掌握了*args、**kwargs

现在学习拆包时，也用到了*、**

那它们之间有什么关系呢？

答：没有任何关系，只是长得像罢了

2. 示例
def test1(*args, **kwargs):
    print("----在test1函数中----")
    print("args:", args)
    print("kwargs", kwargs)


def test2(*args, **kwargs):
    print("----在test2函数中----")
    print("args:", args)
    print("kwargs", kwargs)
    test1(args, kwargs)


test2(11, 22, 33, name="王老师", age=18)

运行结果

----在test2函数中----
args: (11, 22, 33)
kwargs {'name': '王老师', 'age': 18}
----在test1函数中----
args: ((11, 22, 33), {'name': '王老师', 'age': 18})
kwargs {}
3. 示例2
def test1(*args, **kwargs):
    print("----在test1函数中----")
    print("args:", args)
    print("kwargs", kwargs)


def test2(*args, **kwargs):
    print("----在test2函数中----")
    print("args:", args)
    print("kwargs", kwargs)
    test1(*args, **kwargs)


test2(11, 22, 33, name="王老师", age=18)

运行结果

----在test2函数中----
args: (11, 22, 33)
kwargs {'name': '王老师', 'age': 18}
----在test1函数中----
args: (11, 22, 33)
kwargs {'name': '王老师', 'age': 18}

匿名函数

一、是什么

匿名函数：没有名字的函数，在Python中用lambda定义

示例

lambda x, y: x + y  # 定义了一个匿名函数 1.没有名字 2.完成2个数的加法操作

二、做什么

  1. 可以用一行代码完成简单的函数定义
  2. 可以当做实参快速传递到函数中去

三、怎样用

用lambda关键词能匿名函数。这种函数得名于省略了用def声明函数的标准步骤

1. 格式

lambda函数的语法只包含一个语句，如下：

lambda 形参1, 形参2, 形参3: 表达式

2. 注意

lambda函数能接收任何数量的参数但只能返回一个表达式的值，其默认就是返回的，不用写return

3. 使用方式

既然我们已经知道def定义函数时的变量存储的是函数的引用，所以只要有了这个函数的引用，也就可以通过变量名()的方式调用函数

而，函数分为def定义的普通函数，和用lambda定义的匿名函数，所以无论一个变量例如b保存的是普通函数的引用，还是匿名函数的引用，都可以用b()方式调用b指向的函数

一般情况下对匿名函数的使用有2种方式

  1. 通过lambda定义匿名函数，然后用一个变量指向这个匿名函数，然后通过变量名()调用这个匿名函数
  2. 直接在调用其它函数实参的位置通过lambda定义匿名函数，会将这个匿名函数的引用当做实参进行传递
方式1示例：
# 定义了一个匿名函数，然后让变量add_2_nums指向它
add_2_nums = lambda x, y: x + y

# 调用add_2_nums指向的匿名函数
print("10+20=" % add_2_nums(10, 20))

以上实例输出结果：

0+20=30
方式2示例：
def fun(a, b, opt):
    print("a = %d" % a)
    print("b = %d" % b)
    print("result = %d" % opt(a, b))  # 此时opt指向了第7行定义的匿名函数，所以opt(a, b)就相当于调用匿名函数


fun(1, 2, lambda x, y: x + y)  # 定义一个匿名函数，且将它的引用当做实参进行传递
其他语言匿名函数及Lambda：
  1. javascript、ES6新增语法“箭头函数”，例：(a,b)=>{return a+b;}
  2. C#的匿名函数，例：
var func = ((Func<int, int, int>)((x, y) =>
            {
                return x+y;
            }));

引用id(a)可以查询a变量地址

文章转自：https://doc.itprojects.cn/0001.zhishi/python.0001.python3kuaisurumen/index.html#/README
截取部分需要备忘和语法糖部分记录

0
暂无标签
版权属于： Elysian
本文链接： https://blog.icheguo.com/python/299.html
作品采用： 《 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 》许可协议授权

评论

博主关闭了所有页面的评论