关于python:自学python

一、软件装置及工具筹备

1.装置python
装置python3:
brew install python3

查看命令:python3【间接回车】,如图则证实曾经胜利装置,否则为未装置【退出时可输出:exit()而后点回车】

2.装置pip
# 下载安装脚本
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py 

# 运行装置脚本
sudo python3 get-pip.py 

#常用命令

#降级命令
pip pip3 install -U pip

#安装包命令
pip install Package # 最新版本
pip install Package==1.0.4 # 指定版本
pip install 'Package>=1.0.4' # 最小版本

查看命令:pip3 –version【python3版本的命令】如图:证实曾经胜利装置

3.装置Vscode 【Download Visual Studio Code】

装置汉化插件【扩大插件搜寻 chinese】

装置python插件【扩大插件搜寻 python】

配置python运行指向python3的门路

装置python插件【扩大插件搜寻 code runner】

装置胜利后点击.py文件,右上角呈现运行小三角即代表胜利

二、Python 学习(入门级别)

1.Python 数据类型

内置数据类型,在编程中,数据类型是一个重要的概念。
变量能够存储不同类型的数据,并且不同类型能够执行不同的操作。
在这些类别中,Python 默认领有以下内置数据类型:

类型 变量
文本类型 str
数值类型 int, float, complex
序列类型 list, tuple, range
映射类型 dict
汇合类型 set, frozenset
布尔类型 bool
二进制类型 bytes, bytearray, memoryview
  • Python 数字

    #Python 中有三种数字类型:
    int、float、complex
    #为变量赋值时,将创立数值类型的变量,实例:
    x = 10   # int
    y = 6.3  # float
    z = 2j   # complex
    #如需验证 Python 中任何对象的类型,请应用 type() 函数,实例:
    print(type(x)) #<class 'int'>
    print(type(y)) #<class 'float'>
    print(type(z)) #<class 'complex'>
  • Python 字符串
    字符串或串(String)是由数字、字母、下划线组成的一串字符。

    str = 'Hello World!'
    
    print(str)            # 输入残缺字符串 Hello World!
    print(str[0])         # 输入字符串中的第一个字符 H 
    print(str[2:5])       # 输入字符串中第三个至第六个之间的字符串 llo
    print(str[2:])        # 输入从第三个字符开始的字符串 llo World!
    print(str * 2)        # 输入字符串两次 Hello World!Hello World!
    print(str + "TEST")   # 输入连贯的字符串 Hello World!TEST
  • Python列表
    List(列表) 是 Python 中应用最频繁的数据类型。
    列表能够实现大多数汇合类的数据结构实现。它反对字符,数字,字符串甚至能够蕴含列表(即嵌套)。
    列表用 [ ] 标识,是 python 最通用的复合数据类型。
    列表中值的切割也能够用到变量 [头下标:尾下标] ,就能够截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标能够为空示意取到头或尾。

    list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
    tinylist = [123, 'john']
     
    print(list)                # 输入残缺列表 ['runoob', 786, 2.23, 'john', 70.2]
    print(list[0])             # 输入列表的第一个元素 runoob
    print(list[1:3])           # 输入第二个至第三个元素 [786, 2.23]
    print(list[2:])            # 输入从第三个开始至列表开端的所有元素 [2.23, 'john', 70.2]
    print(tinylist * 2)        # 输入列表两次 [123, 'john', 123, 'john']
    print(list + tinylist)     # 打印组合的列表 ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
  • Python 元组
    元组是另一个数据类型,相似于 List(列表)。
    元组用 () 标识。外部元素用逗号隔开。然而元组不能二次赋值,相当于只读列表。

    tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
    tinytuple = (123, 'john')
    
    print(tuple)               # 输入残缺元组 ('runoob', 786, 2.23, 'john', 70.2)
    print(tuple[0])            # 输入元组的第一个元素 runoob
    print(tuple[1:3])          # 输入第二个至第四个(不蕴含)的元素 (786, 2.23)
    print(tuple[2:])           # 输入从第三个开始至列表开端的所有元素 (2.23, 'john', 70.2)
    print(tinytuple * 2)       # 输入元组两次 (123, 'john', 123, 'john')
    print(tuple + tinytuple)   # 打印组合的元组 ('runoob', 786, 2.23, 'john', 70.2, 123, 'john')
  • Python 字典
    字典(dictionary)是除列表以外python之中最灵便的内置数据结构类型。列表是有序的对象汇合,字典是无序的对象汇合。
    两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
    字典用”{ }”标识。字典由索引(key)和它对应的值value组成。

    dict = {}
    dict['one'] = "one"  # {'one':'one'}
    dict[2] = "two"     # {2:'two'}
    tinydict = {'name': 'runoob', 'code': 6734, 'dept': 'sales'}
    
    print(dict['one'])         # 输入键为'one' 的值 one
    print(dict[2])             # 输入键为 2 的值 two
    print(tinydict)            # 输入残缺的字典 {'dept': 'sales', 'code': 6734, 'name': 'runoob'}
    print(tinydict.keys())     # 输入所有键 ['dept', 'code', 'name']
    print(tinydict.values())   # 输入所有值 ['sales', 6734, 'runoob']
    
  • Python数据类型转换
    有时候,咱们须要对数据内置的类型进行转换,数据类型的转换,你只须要将数据类型作为函数名即可。
    以下几个内置的函数能够执行数据类型之间的转换。这些函数返回一个新的对象,示意转换的值。

    函数 形容
    int(x [,base]) 将x转换为一个整数
    long(x [,base] ) 将x转换为一个长整数
    float(x) 将x转换到一个浮点数
    complex(real [,imag]) 创立一个复数
    str(x) 将对象 x 转换为字符串
    repr(x) 将对象 x 转换为表达式字符串
    eval(str) 用来计算在字符串中的无效Python表达式,并返回一个对象
    tuple(s) 将序列 s 转换为一个元组
    list(s) 将序列 s 转换为一个列表
    set(s) 转换为可变汇合
    dict(d) 创立一个字典。d 必须是一个序列 (key,value)元组。
    frozenset(s) 转换为不可变汇合
    chr(x) 将一个整数转换为一个字符
    unichr(x) 将一个整数转换为Unicode字符
    ord(x) 将一个字符转换为它的整数值
    hex(x) 将一个整数转换为一个十六进制字符串
    oct(x) 将一个整数转换为一个八进制字符串
    有时您可能须要为变量指定类型。这能够通过 casting 来实现。 Python 是一门面向对象的语言,因而它应用类来定义数据类型,包含其原始类型。
    
    因而,应用构造函数实现在 python 中的转换,实例:
    
    int() - 用整数字面量、浮点字面量结构整数(通过对数进行下舍入),或者用示意残缺数字的字符串字面量
    float() - 用整数字面量、浮点字面量,或字符串字面量结构浮点数(提供示意浮点数或整数的字符串)
    str() - 用各种数据类型结构字符串,包含字符串,整数字面量和浮点字面量
    实例
    整数:
    
    x = int(1)   # x 将是 1
    y = int(2.5) # y 将是 2
    z = int("3") # z 将是 3
    
    实例浮点数:
    
    x = float(1)     # x 将是 1.0
    y = float(2.5)   # y 将是 2.5
    z = float("3")   # z 将是 3.0
    w = float("4.6")# w 将是 4.6
    
    实例字符串:
    
    x = str("S2") # x 将是 'S2'
    y = str(3)    # y 将是 '3'
    z = str(4.0)  # z 将是 '4.0'
2. Python 运算符
  • Python算术运算符
    以下假如变量: a=10,b=20:

    运算符 形容 实例
    + 加 – 两个对象相加 a + b 输入后果 30
    减 – 失去正数或是一个数减去另一个数 a * b 输入后果 200
    * 乘 – 两个数相乘或是返回一个被反复若干次的字符串 a * b 输入后果 200
    / 除 – x除以y b / a 输入后果 2
    % 取模 – 返回除法的余数 b % a 输入后果 0
    ** 幂 – 返回x的y次幂 a**b 为10的20次方 输入后果 100000000000000000000
    // 取整除 – 返回商的整数局部(向下取整) 9//2 = 4 | -9//2 = -5

    以下实例演示了Python所有算术运算符的操作:

    a = 21
    b = 10
    c = 0
    
    c = a + b
    print("1. c 的值为:", c)  # 31
    
    c = a - b
    print("2. c 的值为:", c)  # 11
    
    c = a * b
    print("3. c 的值为:", c)  # 210
    
    c = a / b
    print("4. c 的值为:", c)  # 2.1
    
    c = a % b
    print("5. c 的值为:", c)  # 1
    
    # 批改变量 a 、b 、c
    a = 2
    b = 3
    c = a**b
    print("6. c 的值为:", c)  # 8
    
    a = 10
    b = 5
    c = a//b
    print("7. c 的值为:", c)  # 2
  • Python比拟运算符
    以下假如变量: a=10,b=20:

    运算符 形容 实例
    == 等于 – 比拟对象是否相等 (a == b) 返回 False
    != 不等于 – 比拟两个对象是否不相等 (a != b) 返回 True
    > 大于 – 返回x是否大于y (a > b) 返回 False
    < 小于 – 返回x是否小于y。所有比拟运算符返回1示意真,返回0示意假。这别离与非凡的变量 True 和 False 等价 (a < b) 返回 True
    >= 大于等于 – 返回x是否大于等于y (a >= b) 返回 False
    <= 小于等于 – 返回x是否小于等于y (a <= b) 返回 True

    操作实例:

    a = 21
    b = 10
    c = 0
    
    if a == b:
      print("1 - a 等于 b") 
    else:
      print("1 - a 不等于 b")
    
    if a != b:
      print("2 - a 不等于 b")
    else:
      print("2 - a 等于 b")
    
    if a < b:
      print("4 - a 小于 b")
    else:
      print("4 - a 大于等于 b")
    
    if a > b:
      print("5 - a 大于 b")
    else:
      print("5 - a 小于等于 b")
    
    # 批改变量 a 和 b 的值
    a = 5
    b = 20
    if a <= b:
      print("6 - a 小于等于 b")
    else:
      print("6 - a 大于  b")
    
    if b >= a:
      print("7 - b 大于等于 a")
    else:
      print("7 - b 小于 a")
  • Python赋值运算符
    以下假如变量: a=10,b=20:

    运算符 形容 实例
    = 简略的赋值运算符 c = a + b 将 a + b 的运算后果赋值为 c
    += 加法赋值运算符 c += a 等效于 c = c + a
    -= 减法赋值运算符 c -= a 等效于 c = c – a
    *= 乘法赋值运算符 c = a 等效于 c = c a
    /= 除法赋值运算符 c /= a 等效于 c = c / a
    %= 取模赋值运算符 c %= a 等效于 c = c % a
    **= 幂赋值运算符 c = a 等效于 c = c a
    //= 取整除赋值运算符 c //= a 等效于 c = c // a

    操作实例:

    a = 21
    b = 10
    c = 0
    
    c = a + b
    print("1. c 的值为:", c) # 1. c 的值为: 31
    
    c += a
    print("2. c 的值为:", c) # 2. c 的值为: 52
    
    c *= a
    print("3. c 的值为:", c) # 3. c 的值为: 1092
    
    c /= a
    print("4. c 的值为:", c) # 4. c 的值为: 52.0
    
    c = 2
    c %= a
    print("5. c 的值为:", c) # 5. c 的值为: 2
    
    c **= a
    print("6. c 的值为:", c) # 6. c 的值为: 2097152
    
    c //= a
    print("7. c 的值为:", c) # 7. c 的值为: 99864
    
  • Python逻辑运算符
    以下假如变量: a=10,b=20:

    运算符 形容 实例
    and x and y 布尔”与” – 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值 (a and b) 返回 20
    or x or y 布尔”或” – 如果 x 是非 0,它返回 x 的计算值,否则它返回 y 的计算值 (a or b) 返回 10
    not not x 布尔”非” – 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True not(a and b) 返回 False

    操作实例:

    a = 10
    b = 20
    
    if a and b:
      print("1. 变量 a 和 b 都为 True")
    else:
      print("1. 变量 a 和 b 有一个不为 True")
    
    if a or b:
      print("2. 变量 a 和 b 都为 True,或其中一个变量为 True")
    else:
      print("2. 变量 a 和 b 都不为 True")
    
    # 批改变量 a 的值
    a = 0
    if a and b:
      print("3. 变量 a 和 b 都为 True")
    else:
      print("3. 变量 a 和 b 有一个不为 True")
    
    if a or b:
      print("4. 变量 a 和 b 都为 True,或其中一个变量为 True")
    else:
      print("4. 变量 a 和 b 都不为 True")
    
    if not(a and b):
      print("5. 变量 a 和 b 都为 False,或其中一个变量为 False")
    else:
      print("5. 变量 a 和 b 都为 True")
    
  • Python成员运算符
    除了以上的一些运算符之外,Python还反对成员运算符,测试实例中蕴含了一系列的成员,包含字符串,列表或元组。

    运算符 形容 实例
    in 如果在指定的序列中找到值返回 True,否则返回 False x 在 y 序列中 , 如果 x 在 y 序列中返回 True
    not in 如果在指定的序列中没有找到值返回 True,否则返回 False x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

    操作实例:

    a = 10
    b = 20
    list = [1, 2, 3, 4, 5]
    
    if (a in list):
      print("1. 变量 a 在给定的列表中 list 中")
    else:
      print("1. 变量 a 不在给定的列表中 list 中")
    
    if (b not in list):
      print("2. 变量 b 不在给定的列表中 list 中")
    else:
      print("2. 变量 b 在给定的列表中 list 中")
    
    # 批改变量 a 的值
    a = 2
    if (a in list):
      print("3. 变量 a 在给定的列表中 list 中")
    else:
      print("3. 变量 a 不在给定的列表中 list 中")
    
  • Python身份运算符
    身份运算符用于比拟两个对象的存储单元

    运算符 形容 实例
    is is 是判断两个标识符是不是援用自一个对象 x is y, 相似 id(x) == id(y) , 如果援用的是同一个对象则返回 True,否则返回 False
    is not is not 是判断两个标识符是不是援用自不同对象 x is not y , 相似 id(a) != id(b)。如果援用的不是同一个对象则返回后果 True,否则返回 False

    操作实例:

    a = 20
    b = 20
    
    if (a is b):
      print("1. a 和 b 有雷同的标识")
    else:
      print("1. a 和 b 没有雷同的标识")
    
    if (a is not b):
      print("2. a 和 b 没有雷同的标识")
    else:
      print("2. a 和 b 有雷同的标识")
    
    # 批改变量 b 的值
    b = 30
    if (a is b):
      print("3. a 和 b 有雷同的标识")
    else:
      print("3. a 和 b 没有雷同的标识")
    
    if (a is not b):
      print("4. a 和 b 没有雷同的标识")
    else:
      print("4. a 和 b 有雷同的标识")
    
3. Python 条件语句

Python条件语句是通过一条或多条语句的执行后果(True或者False)来决定执行的代码块。
能够通过下图来简略理解条件语句的执行过程:

Python程序语言指定任何非0和非空(null)值为true,0 或者 null为false。

Python 编程中 if 语句用于控制程序的执行,根本模式为:

if 判断条件:
    执行语句……
else:
    执行语句……

其中”判断条件”成立时(非零),则执行前面的语句,而执行内容能够多行,以缩进来辨别示意同一范畴。

else 为可选语句,当须要在条件不成立时执行内容则能够执行相干语句。
操作实例:

# 例1:if 根本用法
flag = False
name = 'python'
if name == 'python':         # 判断变量是否为 python
    flag = True              # 条件成立时设置标记为真
    print('我是python')       # 并输入欢送信息
else:
    print('我是'+name)        # 条件不成立时输入变量名称

print('flag:', flag)

if 语句的判断条件能够用>(大于)、<(小于)、==(等于)、>=(大于等于)、<=(小于等于)来示意其关系。
当判断条件为多个值时,能够应用以下模式:

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

操作实例:

# 例2:elif用法

num = 5
if num == 0:            # 判断num的值
    print('等于0')
elif num == 1:
    print('等于1')
elif num > 3:
    print('大于3')
elif num >= 2:
    print('大于等于2')
else:
    print('以上都不是')      # 条件均不成立时输入

python多个条件判断,只能用 elif 来实现,如果判断须要多个条件需同时判断时,能够应用 or (或),示意两个条件有一个成立时判断条件胜利;应用 and (与)时,示意只有两个条件同时成立的状况下,判断条件才胜利。

操作实例:

# 例3:if语句多个条件

num = 9
if num >= 0 and num <= 10:    # 判断值是否在0~10之间
    print('是的')
# 输入后果: 是的

num = 10
if num < 0 or num > 10:    # 判断值是否在小于0或大于10
    print('是的')
else:
    print('不是')
# 输入后果: 不是

num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):
    print('是的')
else:
    print('不是')
# 输入后果: 不是
3. Python 循环语句

Python的循环语句,程序在个别状况下是按程序执行的。

编程语言提供了各种控制结构,容许更简单的执行门路。

循环语句容许咱们执行一个语句或语句组屡次,上面是在大多数编程语言中的循环语句的个别模式:

Python 提供了 for 循环和 while 循环(在 Python 中没有 do..while 循环):

循环语句

循环类型 形容
while 循环 在给定的判断条件为 true 时执行循环体,否则退出循环体。
for 循环 反复执行语句
嵌套循环 你能够在while循环体中嵌套for循环

循环管制语句

循环管制语句能够更改语句执行的程序。Python反对以下循环管制语句:

循环类型 形容
break 在语句块执行过程中终止循环,并且跳出整个循环
continue 在语句块执行过程中终止以后循环,跳出该次循环,执行下一次循环
pass pass是空语句,是为了放弃程序结构的完整性(不重要可疏忽)
  • Python While 循环语句
    Python 编程中 while 语句用于循环执行程序,即在某条件下,循环执行某段程序,以解决须要反复解决的雷同工作。其根本模式为:

    while 判断条件(condition):
      执行语句(statements)……

    操作实例:

    count = 0
    print("开始!")
    while (count < 9):
      print('The count is:', count)
      count = count + 1
    
    print("完结!")
    
    # 输入后果
    开始!
    The count is: 0
    The count is: 1
    The count is: 2
    The count is: 3
    The count is: 4
    The count is: 5
    The count is: 6
    The count is: 7
    The count is: 8
    完结!
    

    while 语句时还有另外两个重要的命令 continue,break 来跳过循环,continue 用于跳过该次循环,break 则是用于退出循环,此外”判断条件”还能够是个常值,示意循环必然成立,具体用法如下:

    # continue 和 break 用法
    
    i = 1
    while i < 10:
      i += 1
      if i % 2 > 0:   # 非单数时跳过输入
          continue    # 满足某个条件的时候判断是否须要执行后续代码
      print(i)        # 输入单数2、4、6、8、10
    
    i = 1
    print('----分割线---')
    while (True):            # 循环条件为1必然成立
      print(i)        # 输入1、4、7、10
      i += 3
      if i > 10:     # 当i大于10时跳出循环
          break      # 跳出循环
    
    

    循环应用 else 语句

    在 python 中,while … else 在循环条件为 false 时执行 else 语句块:

    count = 0
    while count < 3:
        print(count, " 小于 3")
        count = count + 1
    else:
        print(count, " 不小于 3")
    
    # 输入后果
    # 0  小于 3
    # 1  小于 3
    # 2  小于 3
    # 3  不小于 3
    

    有限循环

    如果条件判断语句永远为 true,循环将会有限的执行上来,事实编码要防止此状况产生,会造成程序解体,如下实例:

    var = 1
    while var == 1:  # 该条件永远为true,循环将有限执行上来
        print("执行代码")
    
    print("完结!")
    
    #执行代码
    #执行代码
    #执行代码
    #执行代码
    #...... 
    # Traceback (most recent call last):
    #  File "/Users/coolpanda/自动化测试/python/interfaceTest/test.py", line 3, in <module>
    #    print("执行代码")
    # KeyboardInterrupt
    
    # 留神:以上的有限循环你能够应用 Control+C  来中断循环。
    
  • Python for 循环语句
    Python for循环能够遍历任何序列的我的项目,如一个列表或者一个字符串。
    语法:

    # for循环的语法格局如下:
    for key in obj:
     statements(s)

    实例:

    # 字符串遍历
    for a in 'Python':     # 第一个实例
        print("以后字母: ", a)
    
    print("------分割线------")
    
    # List(列表)遍历
    fruits = ['苹果', '西瓜',  '哈密瓜']
    for fruit in fruits:        # 第二个实例
        print('以后水果: ', fruit)
    
    print("完结!")
    # 输入后果
    # 以后字母:  P
    # 以后字母:  y
    # 以后字母:  t
    # 以后字母:  h
    # 以后字母:  o
    # 以后字母:  n
    # ------分割线------
    # 以后水果:  苹果
    # 以后水果:  西瓜
    # 以后水果:  哈密瓜
    # 完结!

    通过序列索引迭代

    fruits = ['苹果', '西瓜',  '哈密瓜']
    for index in range(len(fruits)):
        print(fruits[index])
    
    print("以上代码相当于>")
    print(fruits[0])
    print(fruits[1])
    print(fruits[2])
    

    for 语句时同样有两个重要的命令 continue,break 来跳过循环,continue 用于跳过该次循环,break 则是用于退出循环,此外”判断条件”还能够是个常值,示意循环必然成立,具体用法如下:

    fruits = ['苹果', '西瓜',  '哈密瓜', '草莓', '榴莲']
    for fruit in fruits:
        if(fruit == '苹果'):
            continue  # 找到苹果 不打印 间接查找下一个
        elif(fruit == '草莓'):
            break  # 找到草莓 跳出循环
        print(fruit)
    # 输入后果
    # 西瓜
    # 哈密瓜
  • Python 循环嵌套
    Python 语言容许在一个循环体外面嵌入另一个循环,依据事实场景实践上能够始终嵌套

    #Python for 循环嵌套语法:
    
    for iterating_var in sequence:
       for iterating_var in sequence:
          statements(s)
       statements(s)
    
    #Python while 循环嵌套语法:
    
    while expression:
       while expression:
          statement(s)
       statement(s)

    实例:

     # while 循环嵌套
    i = 2
    while(i < 10):
      j = 2
      while(j <= (i/j)):
          if not(i % j):
              break
          j = j + 1
      if (j > i/j):
          print(i, " 是质数")
      i = i + 1
    
    # 输入后果 
    # 2  是质数
    # 3  是质数
    # 5  是质数
    # 7  是质数
    
    # for 循环嵌套
    list = [2, 5, 7, 9, 11]
    for num in range(10):  # 迭代 0 到 10 之间的数字
      for i in list:  # 依据因子迭代
          if num == i:      # 确定第一个因子
              print('%d 在10中' % (i))
              break  # 跳出以后循环
    
    # 输入后果 
    # 2 在10中
    # 5 在10中
    # 7 在10中
    # 9 在10中
    
4. Python 函数

函数是组织好的,可重复使用的,用来实现繁多,或相关联性能的代码段。

函数能进步利用的模块性,和代码的反复利用率。你曾经晓得Python提供了许多内建函数,比方print()。但你也能够本人创立函数,这被叫做用户自定义函数。

定义一个函数
你能够定义一个由本人想要性能的函数,以下是简略的规定:

  • 函数代码块以 def 关键词结尾,后接函数标识符名称和圆括号()。
  • 任何传入参数和自变量必须放在圆括号两头。圆括号之间能够用于定义参数。
  • 函数的第一行语句能够选择性地应用文档字符串—用于寄存函数阐明。
  • 函数内容以冒号起始,并且缩进。
  • return [表达式] 完结函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法

def 函数名称( 参数名称 ):
   "函数_文档字符串"
   function_suite
   return [表达式]

实例:

def speak(str):
    print('传入参数', str)  # 打印参数
    return '你好'  # 返回数据 不写默认返回 None        


a = speak('请谈话')  # 接管并调用函数
print('函数返回:', a)

# 输入后果:
# 传入参数 请谈话
# 函数返回: 你好

# 备注:
# 1.参数(str)可选
# 2.return 返回表达式可选
# 3.a = 变量接管回掉可选

# 即:简略版本


def speak1():
    print('执行函数')  # 打印参数


speak1()  # 接管并调用函数
# 输入后果:
# 执行函数

【腾讯云】轻量 2核2G4M,首年65元

阿里云限时活动-云数据库 RDS MySQL  1核2G配置 1.88/月 速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

您可能还喜欢...

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据