Python

python的基础知识

定义变量

Python定义变量没有修饰词，相对于js来说简单了很多，不需要去记住各种修饰词的意义。

 string = "hello world"

• 使用Python当作计算器（非重点）

• 运算符

  常见的运算符：+（加）、-（减）、*（乘）、/（除） 、**（幂）、%(余)

  赋值的运算符：=

  如果给未定义的变量分配了值，就会报错。

• 文本

  当出文本的时候，如果字符内正好能组成一些特殊的字符如：\r \n 这种，在引号前加一个字符r 就让文本以原始字符输出。

  # here \n means newline!
  print('C:\some\name')  
  C:\some
  ame
  # note the r before the quote
  print(r'C:\some\name')  
  C:\some\name
  

列表

python中有许多复合数据类型，用于将他们组装起来。最常用的就是list 它可以写成[]中间以‘，’分割的值（项）的列表。(也就是js中的数组在python中被称之为列表)；他与字符串一样的，都有内置的序列一样，有序列将意味着它可以被索引和切片。

arr = [1,2,3,4]
print(arr)
[1,2,3,4]
print(arr[1])
2
print(arr[-3:])
[2,3,4]

• 在切片中的负数代表意思是：如同js中的数组下标一样是开始于0，结束于数组的最后一项，这代表数组中项的唯一下标，但是在python中不一样的存在是因为，python中同一项的下标不固定，分为正负两个数，正数的下标从0开始，负数的下标从-1开始，原因是0和-0是相等的，如是负数则是将从列表的末尾开始选的。

列表的方法

• 添加

  arr = [1,2,3,4]
  arr.append(value)
  

  用方法append方式向列表(js中的数组)内的末尾添加数据。

• 长度

  len(arr)
  

  获取列表的长度，就相当于js中的length方法一样就是获取整列表的长度。

• 切片

  newArr = arr[:] #[1,2,3,4]
  newArr[:] = []  #[]
  

  [:]冒号就是代表切片得意思（理解成js得数组的分割操作）[start:end]如果start有值则从标值是start的开始计算，如果为空则为第零位，end则是从尾部开始的。

  arr = [1:2] # [2,3]
  arr = [3:]  # []
  arr = [0:4] # [1,2,3]
  

  如果从列表没有的项开始的话则会返回一个[],如果是不管结束的时候的末尾是的值是否是列表存在的都只会返回[]。如果开始值是数组存在的那么返回值就会是从开始至结束得值。如果结束得值是列表不存在得那么就会从开始值知道返回到列表得最后一个值。

  arr[1:2]= [] #[1,4]
  

  切片是可以赋值的它可以替换掉当前切片位置内容的值。

  总体来说，切片这个方法的命名很贴合，他就是像将数据从这些列表（数组）中拿出来，如果没有后续的赋值，修改什么的操作的话返回的是你当前切片取的值，如果进行了赋值操作它会返回整个操作之后的列表。

流程控制语句

if

x = int(input("请输入数字"))
if x < 0:
 	x = 0
    print("您输入的数字小于0")
elif x == 0:
    print("您输入的数字是0")
elif x == 1:
    print("您输入的是"+ str(x)) 
    # str(x) 原因是 x是int类型 pythone中是没有隐式数据类型转换的

如同js的if判断相同但是区别是if后的判断条件不用（）将其包裹起来，如果是多层判断的时候跟js的区别是如果是js的话就是else if 但是pythone则是 elif。

循环方法

while

# 创建一个斐波那契数列
a,b =0,1
while a<10:
    print(a)
    a,b=b,a+b

while的循环条件如果a小于10那么循环就会一直执行，如果不像打印的值每一个值都占用一行的情况下那么就要用

print(a,end=",")

这种方式进行拼接。

for

arr = [1,2,3,4]
for w in arr
	print(w)
#1
...
#4

基础的语法与js是非常类似的。

users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}
for user, status in users.copy().items():
# users.copy().items()的值是dict_items([('Hans', 'active'), ('Éléonore', 'inactive'), ('景太郎', 'active')])
    if status == 'inactive':
        # user,status类似于js中的结构赋值的概念,将user和status分别取值key和value
        del users[user]
        # del 属性则是删除相应的key值

从代码来看是一个for循环对一个集合(js中的对象)进行遍历，会有 key:value 的概念，copy的意识事赋值是深拷贝，是不会影响原有的集合的。

range()函数

range(10)的意思就是生成一个长度为10的序列的所有合法索引，他的入参有三个range(startvalue,endValue,step),分别是开始值，结束值，步长。

1. 当range(10) 只输入开始值得时候,他代表了创建了长度为10得合法索引

   num = 0
   for i in range(10):
   	num = i
   	print(i)
   #0....9
   

2. 当range(1,5)输入了开始值和结束值的时候，他代表了创建了一个从1开始到4结束的合法索引

   for i in range(1,5):
       num = i 
       print(num)
   #1,2,3,4
   #从1开始到4结束,不包含5
   

3. 当range(0,10,3)输入了开始值和结束值还有步长得时候，他代表了创建了一个从0开始到10结束，中间的差值是3的合法索引

   for i in range(0,10,3):
       num = i
       print(num)
   #0,3,6,9
   

循环中的break、continue语句及else子句

break语句

break语句的意思是跳出最近一层for或while循环。

for i in range(2,10):
    for x in range(2,i):
        if i % x == 0:
            print(i,"等于",x,'*',i)
            break
    else:
        print(i,"是素数")

这段代码中的else语句并不是和if语句一起进行的块，因为他是双层for循环的嵌套，将else与for关联的原因是为了避免二级的循环的重复打印else的方法。

continue语句

continue强制中断此次循环进入下一次循环中

for i in range(0,10):
	if i % 2 == 0:
		print(i,"偶数")
		continue
	print(i,"非偶数")

else语句

重点：在js中else只能与if关联，在python中的else是可以与for或者while循环进行关联的，代表的是，如果在for循环中正常结束，所谓正常结束就是如果在for循环中没有碰到强中断跳出的语句如break、continue等语句时，当此次循环全部循环结束时会进入else执行方法。而在while中else会在循环条件的值为假值时，执行。

n = 0
while n <10:
    n = n +1
    if n % 2 == 0:
    	print(n,"偶数")
        continue
else:
	print("循环结束")
#2 偶数
#4 偶数
#6 偶数
#8 偶数
#10 偶数
#循环结束

pass 语句

pass语句不执行任何操作。是语法上需要的一个语句，在程序中必须要写语句但是有没有任何动作时，可以使用该语句。

while true:
    pass

#创建出一个最小的类
calss MyClass : 
    pass 

#pass还可以用作函数或者条件语句的占位符。
def initlog(*args):
    pass

match 语句

match语句和js中的非常类似，我理解为条件判断语句，或者说是匹配模式的。

def http_error(status):
    macth status:
        case 400 :
            return "请求报错"
        case 302 :
            return "请求重定向"
        case 500 :
            return "服务器报错"
        case _ :
            return "请求成功！"

在最后的匹配中是”_”,这代表的意思与js中的default,如果上面的值都没匹配上的时候就会进入default中，类似于默认值，在python中叫”通配符”。

函数

定义函数

定义函数使用关键字def，后跟函数名与括号内的形参列表。函数从下一句开始，且必须缩进。

def fib (n):
    """ 打印一个斐波那契数列，最多n """
    a,b = 0,1
    while a < n:
        print(a,end=",")
        a,b = b,a+b
   print()
fib(1997)

函数内的一条语句是字符串时，该字符串就是文档字符串，也称为docstring。

def newFib (n):
	"""返回一个斐波那契数列列表，最多n"""
    newArr = []
    a,b = 0,1
    while a < n:
		newArr.append(a)
    	a,b = b,a+b
    return newArr
newFib(100)

函数定义详解

函数定义支持可变数量的参数。

默认值参数

def ask_ok(prompt,retries=4,reminder="请再次输入"):
    while True:
        replay = input(prompt)
        if replay in {'y','ye','yes'}:
            return True
        if replay in {'n','no','nop','nope'}:
            return False
        retries = retries -1 
        if retries < 0:
            raise ValueError('账号锁定')
        print(reminder)

这里的默认传参就和js中很类似了，就是非比传得参数，如果调用方法得时候传入了新得数值，那么传入得数值会替代掉之前的默认值。

def f(a,L=[]):
	L.append(a)
    return L
print(f(1))
print(f(2))
print(f(3))
#[1]
#[1,2]
#[1,2,3]

如果之后不想在后续调用之间共享默认值时，就可以用下面的方式编写函数

def f(a,L="none"):
    if L == "none":
        L = []
    L.append(a)
    return L

关键字参数

kwarg=value 形式的 关键字参数 也可以用于调用函数。

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print(action, end=' ')
    print(voltage)
    print(state)
    print(type)
#这些是可以正常调用方法的示例    
parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword
#这些是无法正常调用方法的示例
parrot()                     # required argument missing
parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
parrot(110, voltage=220)     # duplicate value for the same argument
parrot(actor='John Cleese')  # unknown keyword argument

这个例子应该是要告诉我们如果你调用一个函数时，你想要指定传给某一个形参的时候你可以用 形参名 = 值的形式但是不能(值,形参名=值)这种形式。

位置或关键字参数

函数定义中的未使用/和*时，参数可以按照位置或者关键字传递给函数。

def fn(a,/,b,*,c):
    pass

在上面的代码中a可以是位置参数也可以是关键字参数，但是b只能是关键字参数因为在b形参之前定义了*,只有在这种字符的定义之后的才会定义成关键字参数，但是c又不是关键字参数了，因为他跟在/,之后就是位置参数，在python中/必须在*之前，如果/在*之后则无法解析这种函数，会报错。

解包实参列表

函数调用要求独立的位置参数，但实参在列表或元组里时，要执行相反的操作。

#内置的range函数有start和stop两个位置形参
list(range(3,6))
#[3,4,5]
arr = [3,6]
list(arr)
#[3,6]
list(range(*arr))
#[3,4,5]
#如果直接`list(range(arr))`则会报错

Lambda表达式

lambda 关键字用于创建小巧的匿名函数。

def fn(n):
    return lambda x:x*x

f(5)
#25

lambda可以用在任何需要函数的地方，在函数上，匿名函数只能是单个表达式。在语义上，他只常规函数的语法糖，可以调用包含作用域的变量。如果一个函数只是执行表达式的时候就可以用lambda表达进行编写。

文档字符串

def my_function():
    """Do nothing, but document it.

    No, really, it doesn't do anything.
    """
    pass

print(my_function.__doc__)

目前了解到的就是一种规范，来说明当前代码的最主要的功能，起到最主要的功能就是说明代码的功能。

函数注解

函数注解是可选的用户自定义函数类型的元数据完整信息。

def f(ham: str, eggs: str = 'eggs') -> str:
    print("Annotations:", f.__annotations__)
    print("Arguments:", ham, eggs)
    return ham + ' and ' + eggs

f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

标注是以字典形式（dict）存放在函数的__annotations__属性中并且对函数的其他部分没有影响的。形参标注是在形参名后面加个：,后面会跟一个被要求值标注的值的表达式。使用方式是必须在编写代码时就得给形参名后:数据类型这种方式后才能获取的注解。

原文链接：https://juejin.cn/post/7345396671424413705 作者：用户4536111032191