【Python-语法】

■ 变量

■ 单行注释#，多行注释 “”“XXX”“”

■ 编码方式

■ 行与缩进

■ 示例一：缩进不一致，会导致运行错误

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会导致运行错误
  
以上程序由于缩进不一致，执行后会出现类似以下错误：
 File "test.py", line 6
    print ("False")    # 缩进不一致，会导致运行错误
                                      ^
IndentationError: unindent does not match any outer indentation level

■ 代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

if expression :   #该行之后的一行或多行代码构成代码组。
   suite      
elif expression :  #该行之后的一行或多行代码构成代码组。
   suite 
else :           #该行之后的一行或多行代码构成代码组。
   suite

■ 多个变量赋值

a = b = c = 1   #创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

a, b, c = 1, 2, "runoob" #两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

■ 多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句，例如：
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 .

total = item_one + \
        item_two + \
        item_three

■ 运算符

■ 算术（数学）运算符 ( + - * / % // ** )

print("1 + 1 = ", 1 + 1)
print("2 - 1 = ", 2 - 1)
print("3 * 3 = ", 3 * 3)
print("4 / 2 = ", 4 / 2)      
print("11 // 2 = ", 11 // 2)    # 结果取整
print("9 % 2 = ", 9 % 2) 
print("2 ** 3 = ", 2 ** 3)      # 2的3次方

结算结果：
1 + 1 =  2
2 - 1 =  1
3 * 3 =  9
4 / 2 =  2.0
11 // 2 =  5
9 % 2 =  1
2 ** 2 =  4

■ 赋值运算符 =

num = 1 + 2 * 3

■ 复合赋值运算符 +=, -= , -=, %=, **=, //=,

num = 1
num += 1 # num = num + 1
print("num += 1: ", num)
num -= 1
print("num -= 1: ", num)
num *= 4
print("num *= 4: ", num)
num /= 2
print("num /= 2: ", num)
num = 3
num %= 2
print("num %= 2: ", num)

num **= 2
print("num **=2: ", num)

num = 9
num //= 2
print("num //= 2:", num)

结果：------------------------------------------------
num += 1:  2
num -= 1:  1
num *= 4:  4
num /= 2:  2.0
num %= 2:  1
num **=2:  1
num //= 2: 4

■ 比较运算符

■ 同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割，以下是一个简单的实例：

#!/usr/bin/python3
 
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

■ print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=“”：

#!/usr/bin/python3
 
x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

以上实例执行结果为：
a
b
---------
a b

name1 = "shine"
name2 = '喜欢'
print(f'name1={name1},name2={name2}')

name1=shine,name2=喜欢

■ import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。

属性	格式为
将整个模块(somemodule)导入	import somemodule
从某个模块中导入某个函数	from somemodule import somefunction
从某个模块中导入多个函数	from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入	from somemodule import *

■ 示例一 导入 sys 模块

import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)

■ 示例二 导入 sys 模块的 argv,path 成员

from sys import argv,path  #  导入特定的成员
 
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

---

■ case _: 类似于 C 和 Java 中的 default:

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"
mystatus=400
print(http_error(400))

以上是一个输出 HTTP 状态码的实例，输出结果为：
Bad request

■ 一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开

...
    case 401|403|404:
        return "Not allowed"

■ while 循环使用 else 语句

#!/usr/bin/python3 
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

执行以上脚本，输出结果如下：
0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

■ for 语句

"""
演示for循环的基础语法
"""
name = "itheima"
for x in name:
    # 将name的内容，挨个取出赋予x临时变量
    # 就可以在循环体内对x进行处理
    print(x)

#!/usr/bin/python3 
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    print(site)

以上代码执行输出结果为：
Baidu
Google
Runoob
Taobao

■ for 统计如下字符串中，有多少个字母a

"""
演示for循环的练习题：数一数有几个a
"""
# 统计如下字符串中，有多少个字母a
name = "itheima is a brand of itcast"

# 定义一个变量，用来统计有多少个a
count = 0

# for 循环统计
# for 临时变量 in 被统计的数据:
for x in name:
    if x == "a":
        count += 1

print(f"被统计的字符串中有{count}个a")

■ for 语句配合 range(num) 生成数列

>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

■ for 语句配合 range(num1,num2) 指定区间的值

>>>for i in range(5,9) :
    print(i)
     
5
6
7
8
>>>

■ for 语句配合 range(num1,num2,step) 指定数字开始并指定不同的增量

>>>for i in range(0, 10, 3) :
    print(i)     
0
3
6
9
>>>

>>>for i in range(-10, -100, -30) :
    print(i)       
-10
-40
-70
>>>

■ for 语句配合 range() 和 len() 函数以遍历一个序列的索引

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

■ 使用 range() 函数来创建一个列表

>>>list(range(5))
[0, 1, 2, 3, 4]
>>>

■ for…else

当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，
如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。

for x in range(6):
  print(x)
else:
  print("Finally finished!")
执行脚本后，输出结果为：
0
1
2
3
4
5
Finally finished!

■ pass 语句

pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句，

实例
>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)
最小的类:

实例
>>>class MyEmptyClass:
...     pass

■ end 关键字

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

#!/usr/bin/python3
 
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b
执行以上程序，输出结果为：

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

■ iter() 迭代器

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
执行以上程序，输出结果如下：
1 2 3 4

■ yield 生成器

yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

def countdown(n):
    while n > 0:
        yield n
        n -= 1
 
# 创建生成器对象
generator = countdown(5)
 
# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
 
# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

■ 函数

# 定义函数
def check():
    # 编写函数体输出信息
    print("欢迎来到黑马程序员！\n请出示您的健康码以及72小时核酸证明！")

# 调用函数
check()

■ 传递参数

# 定义2数相加的函数，通过参数接收被计算的2个数字
def add(x, y, z):
    result = x + y + z
    print(f"{x} + {y} + {z}的计算结果是：{result}")

# 调用函数，传入被计算的2个数字
add(5, 6, 7)

■ return None

# 主动返回None的函数
def say_hi2():
    print("你好呀")
    return None

■ 多个返回值

# 演示使用多个变量，接收多个返回值
def test_return():
    return 1, "hello", True

x, y, z = test_return()
print(x)
print(y)
print(z)
--------------------------
1
hello
True

■ 缺省参数（默认值）实参和形参一一对应

# 缺省参数（默认值）
def user_info(name, age, gender):
    print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")

user_info('小天', 13, '男')

结果：
姓名是:小天, 年龄是:13, 性别是:男

■ 关键字参数

def user_info(name, age, gender):
    print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")
    
# 关键字参数
user_info(name='小王', age=11, gender='女')
user_info(age=10, gender='女', name='潇潇')    # 可以不按照参数的定义顺序传参
user_info('甜甜', gender='女', age=9)

结果：
姓名是:小王, 年龄是:11, 性别是:女
姓名是:潇潇, 年龄是:10, 性别是:女
姓名是:甜甜, 年龄是:9, 性别是:女

■ 默认参数

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

■ * 号 元组（tuple）传参

# 不定长 - 位置不定长, *号
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
    print(f"args参数的类型是：{type(args)}，内容是:{args}")

user_info(1, 2, 3, '小明', '男孩')

结果： 
args参数的类型是：<class 'tuple'>，内容是:(1, 2, 3, '小明', '男孩')

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

以上实例输出结果：
输出: 
70
(60, 50)

■ **号 的参数会以字典的形式导入

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)
以上实例输出结果：

输出: 
1
{'a': 2, 'b': 3}

■ 函数作为参数传递 <class ‘function’>

"""
演示函数作为参数传递
"""
# 定义一个函数，接收另一个函数作为传入参数
def test_func(compute):
    result = compute(1, 2)  # 确定compute是函数
    print(f"compute参数的类型是:{type(compute)}")
    print(f"计算结果：{result}")

# 定义一个函数，准备作为参数传入另一个函数
def compute(x, y):
    return x + y
# 调用，并传入函数
test_func(compute)

--------------------------------------------------
输出结果：
compute参数的类型是:<class 'function'>
计算结果：3

■ lambda 匿名函数

■ 不带参

f = lambda: "Hello, world!"
print(f())  # 输出: Hello, world!

■ 一个参数

x = lambda a : a + 10
print(x(5))

以上实例输出结果：
15

■ 匿名函数设置两个参数

实例匿名函数设置两个参数：
#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

相加后的值为 :  30
相加后的值为 :  40

■ 使用同样的代码来创建多个匿名函数

我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。
以下实例将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数：

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)       # myfunc(2)  == lambda a : a * 2
mytripler = myfunc(3)		# myfunc(3)  == lambda a : a * 3
 
print(mydoubler(11))
print(mytripler(11))
以上实例输出结果：

22
33

■ 与map()、filter() 和 reduce() 一起使用