python基础 上

一 、注释

单行注释 #

多行注释 ''' ''' 或""" """

单行注释快捷键 ctrl + / ，可给多行添加单行注释。

二、变量

变量 内存地址的别名，用来存储数据的

Python里面不需要声明变量类型 但需要注意格式,也不许需要；

name = "习春琼"
age = 18

可以用type()获取数据类型。

三、数据类型

常用数据类型：int、float、str(单引号或双引号引起来都是字符类型)、bool.

四、输出---print

1.基本输出

print()

2.一次输出多个相同或不同内容，每个内容之间用 , 隔开

print("张三",18,3000,10,True)

3.书写表达式

print(1+2)

4.格式化输出 ：格式化占位符（坑位）

%s :字符串
%d ：整数型int
%f ：小数，float型
print("我的年龄是%d" %age)
想要输出一个% 就要使用%%
print("本次考试合格占比人数%d%%" %50)
print(f-string(f"我的名字是{name},年龄{age}岁,身高{heiht}厘米")

5.转义字符：

\n 代表换行
如果不想换行print("hello",end ="")

五、输入---input

python 中的输入用的是input()函数

#input("给用户提示的信息") 得到用户输入的内容，回车键结束

password = input("请输入暗号：" )
print("你的暗号是%s"%password)

1.类型转换

原始数据类型转化成我们需要的数据类型，在这个过程中不会改变原始数据，会生成一个新的数据。

（1）转化成int类型   int(原始数据)
（2）float类型转化成int类型
PI = 3.14
num = int(PI)

​

eval()

在python中，eval（）方法是一个经常用到的函数，我们在编写输入函数的时候，需要把input（）函数写进eval（）方法中，这样得到的输入结果就不会是字符串类型的了。

例如：

a=input('请输入一个数字')
print(type(a))

这样输出的类型就会使String类型的，但是当：

b=eval(input('请输入一个数字'))
print(type(b))

这样输出的类型就是数字类型的，而不是字符串类型的了。

六、运算符

1.算数运算符 +、-、*、/

2.赋值运算符 =

3.比较运算符 >、>=、<、<=、==

4.逻辑运算符

and 逻辑与    两真同真，一假则假
or 逻辑或     一真为真，两假为假
not 逻辑非     取反
​

七、基本结构

（一）判断

1.if 语句

age = int(input("请输入你的年龄："))
if age >= 18:
    print("你是成年人啦！") #满足条件输出
print("if判断结束。")  #程序最后输出

2.if...else...语句

age = int(input("请输入你的年龄："))
if age >= 18:
    print("你是成年人啦！")
else:
    print("你还是个小屁孩。")
print("判断结束")

​

3.if...elif...else...

if...elif...相当于if...if...

score = eval(input("请输入您的python考试成绩："))
if score >= 90:
    print("优秀")
elif score < 90 and(score >= 80):
    print("良好")
elif score < 80 and (score >= 60):
    print("及格")
else:
    print("不及格")

4.if 嵌套

层级关系通过缩进表示

money =eval(input("请输入你的零钱："))
if money >= 2:
    print("上车找座位")
    zuowei = eval(input("请输入座位数"))
    if zuowei >= 1:
        print("有座位，请座")
    else:
        print("没座位，站着")
else:
    print("走路回家")

​

5.随机数模块（random） 含头不含尾

用import导入

产生[a,b]之间的随机整数，包含a和b

num = random.random(a,b)
import random #导入随机数模块
num = random.randint(1,3) #随机产生1,3的随机数
print(num)

判断条件成立，执行表达式1，条件不成立，执行表达式2 变量 = 表达式1 if 判断条件 else 表达式2 #推荐扁平化代码 条件成立，表达式1的值 条件不成立2，表达式2的值

# 案例需求
# 输入两个数字，判断两个数的最大值
a = int(input("请输入第一个数字："))
b = int(input("请输入第二个数字："))
result = a if a > b else b
print(result)

（二） 循环

1.while

while cout <= 100:
    sum += cout
    cout += 1
print("1-100的累加和为%d"%sum)

1.1.while 循环的嵌套

while 条件1：
    代码1
    while 条件2：
        代码 2
eg:
i = 1
while i<= 5:
    print("操场跑的第%d圈" %i)
    #定义变量记录每圈跑完之后的俯卧撑
    j = 1
    while j <= 3:
        print("第",i,"圈俯卧撑第%d个："%j)
        j += 1
    i += 1

2.for

1.1针对可迭代对象:字符串、容器类型（数组、、、）可以一个个输出了

str = "hello"
for item in str:
    print(item)

1.2.rang()函数：用来创建一个生成一系列整数的可迭代对象（也叫整数序列生成器）

语法：

写法1:range(开始点，结束点，间隔点) #返回数字
写法2：range(开始点,结束点)#间隔默认为1
写法3:range(结束点)#开始点默认为0，间隔默认为1

1.3.循环嵌套：

for 变量1 in 可迭代对象1：
    代码1
    for 变量2 in 可迭代对象2:
        代码2
eg:
for i in range(1,6,1):
    print("操场跑的第%d圈" % i)
    for j in range(1,4,1):
        print("第", i, "圈俯卧撑第%d个" %j)

​

3. break和continue

1.break 是中止循环的执行，循环代码遇到break直接结束循环

2.continue结束本次循环，继续执行下一次循环

4.pass

pass关键字 用于占位 空代码 让代码不报错。

5.循环else结构

for x in xx:
    if xxx:
        xx #if成立会执行
    else:
        xxx #if不成立会执行
else:
    xxx  #for循环代码运行结束，但不是被break关键字终止时会执行

​

八、字符串

字符串的定义

1.1单引号和双引号不可以换行，三引号可以进行多行编写

1.2 如果字符串本身包含单引号，使用双引号定义，如果有双引号，可以使用单引号定义

1.3如果包含单引号也包含双引号，可以使用三引号。

1.4 字符串 * num 代表字符串付出输出多少遍

str1 = "*" * 5
print(str1)

1.5 字符串的输入和输出

2.字符串的下标

2.1 下标也称索引，是一个整形数字。可以是正数也可以是负数

2.2 整数下标是从零开始，表示一个字符，-1表示最后一个字符

# 下标的使用语法 变量[下标]
my_str = "Hello"
print(my_str[0]) # h
print(my_str[3]) # l
print(my_str[-1]) # O
print(my_str[-3]) # l

2.3 len( )函数可以得到字符串的长度

print(len(my_str))

2.4

3.切片

3.1 切片：切片可以获取一段数据，多个数据，下标（索引）只能获取一个数据。

3.2 切片的语法：

 变量[start:end:step],得到一个新的字符串。含头不含尾
 #start 开始位置
 # end 结束位置下标(不包含)
 # step 步长，下标之间的间隔默认是1
my_str = "Hello"
my_str1 = my_str[2:4:1]
print(my_str1)  # ll
#start 和 end 位置都可以不写 但冒号必须存在
my_str2 = my_str[:] # 得到和原来一样的字符
print(my_str2) #Hello # 字符串逆序
 # 字符串逆序
my_str3 = my_str[::-1]
print(my_str3) #olleH
#step 如果步长是1 既是默认值 可以不写
my_str4 = my_str[2:4]
print(my_str4)  # ll
​
#end 位置不写，表示len() 即可以取到最后一个元素
my_str5 = my_str[2:]
print(my_str5) #llo
​
# start 位置可以不写表示0
my_str6 = my_str[:3]
print(my_str6) #hel
​
#step 如果步长是1 既是默认值 可以不写
my_str4 = my_str[2:4]
print(my_str4)  # ll
​
#end 位置不写，表示len() 即可以取到最后一个元素
my_str5 = my_str[2:]
print(my_str5) #llo
​
# start 位置可以不写表示0
my_str6 = my_str[:3]
print(my_str6) #hel

4.查找方法

4.1 find( ) 在字符串中查找是否存在某个字符串

4.1.1find ()函数使用语法

find(sub_str,start,end)
#sub_str   要在字符串中查找的内容
#start     开始的位置，从哪开始查 可以省略不写，默认是0
#end       结束位置，查找到哪里结束，默认是len() 可以省略不写
#返回值     即方法执行的结果是什么，如果找到sub_str，则返回sub_str在my_str中的位置的正数下标，如果没有找到则返回-1.
my_str = "hello xcq and jy"
index = my_str.find("xcq") 
print(index) # 6 (从6开始的）  返回第一个位置的下标

4.1.2 rfind( ) 方法

rfind( ) == right find( ) 从右边（后边）开始找
从后面查找，返回的下标是从前开始数的

4.2 index（） 在字符串中查找是否存在某个字符串

index(sub_str,start,end)
#sub_str   要在字符串中查找的内容
#start     开始的位置，从哪开始查 可以省略不写，默认是0
#end       结束位置，查找到哪里结束，默认是len() 可以省略不写
#返回值     即方法执行的结果是什么，如果找到sub_str，则返回sub_str在my_str中的位置的正数下标，如果没有找到则报错.

4.2.2 rindex() 方法

rindex( ) == right index( ) 从右边（后边）开始找
my_str = "hello world tedu num pro tedu" 
print(my_str.index("tedu")) #12
print(my_str.rindex("tedu")) #25
就近原则 --- 哪边靠近用哪边 ，都是返回从前往后的正数下标

5.统计方法

5.1 count( ) 方法 统计出现的次数

count(sub_str,start,end)   
#sub_str   要在字符串中查找的内容
#start     开始的位置，从哪开始查 可以省略不写，默认是0
#end       结束位置，查找到哪里结束，默认是len() 可以省略不写
#返回值     即方法执行的结果是什么，如果找到sub_str，则返回sub_str在my_str中的位置的正数下标，如果没有找到则报错.
print(my_str.count("tedu")) # 2
print(my_str.count("n",15)) # 1
print(my_str.count("o",5,12)) # 1

6.字符串替换

6.1 replace( ) 方法 字符串替换 将old_str 替换为 new_str

 replace( old_str,new_str,count)
 #old_str:将要被替换的字符串
 # new_str：新的字符串，替换成字符串
 #count：替换的次数，默认是全部替换
 #返回值： 得到一个新的字符串，不会改变原来的字符串。
my_str = "hello world tedu nun pro tedu"
my_str1 = my_str.replace("nun","北民大")
print(my_str1)  #hello world tedu 北民大 pro tedu
my_str1 = my_str.replace("tedu","达内",1)
print(my_str1) # hello world tedu 北民大 pro tedu

7. 字符串分割

7.1 split( ) 方法

split(self,step,maxsplit) 将一个字符串按照self进行切割
#self:按照什么内容切割，默认是空白字符，空格，tab键
#step:切割几次，默认是全部切割
#maxsplit: 最大切割次数
#返回值：列表[]
my_str = "hello world tedu nun pro tedu"
my_str1 = my_str.split(" ",2)
print(my_str1) # ['hello', 'world', 'tedu nun pro tedu']
​
my_str2 = my_str.split(" ")
print(my_str2) # ['hello', 'world', 'tedu', 'nun', 'pro', 'tedu']

8 字符串连接

8.1 join( )

# my_str.join( 可迭代对象)
# #可迭代对象，str,列表(需要列表中每一个数据类型都是字符串类型)
# 将my_str 这个字符串添加到可迭代对象像个元素之间
# 返回值：一个新的字符串，不会改变原来的字符串的值
​
my_str ="_*_".join("hello") #就会把_*_加入到hello没两个元素之间
print(my_str)
#定义列表
my_list = ["hello","python","num"]
print("_".join(my_list)) # hello_python_num
print(" ".join(my_list)) #  hello_python_num

九.列表

1. 列表的定义

列表是python中的一种数据类型，可以存储多个数据，列表中的数据可以是任意类型的 列表list,定义用[]进行定义

1.1创建列表

# #列表名 = []
# #列表名 = list(可迭代对象)

1.2定义空列表

#方法1
my_list =[] #空列表
print(my_list,type(my_list))
#方法2
my_list1 = list() #空列表
print(my_list1,type(my_list1))

1.3定义带数据类型的列表

定义带数据类型的列表，数据之间用逗号隔开
my_list2 = [1,3,5,"hello",3.14,"nun","tedu"]
print(my_list2,type(my_list2)) # list[1, 3, 5, 'hello', 3.14, 'nun', 'tedu']

1.4列表的长度

#求列表中的数据元素的个数，即列表的长度
nun =len(my_list2)
print(nun) # 7
​
#列表支持下标和切片
print(my_list2[5]) #nun
print(my_list2[-1]) #tedu
​
print(my_list2[1:3]) #[3, 5] 切片返回是一新列表，不影响源列表

1.5下标操作与字符串中的不同：

字符串不能使用下标修改其中数据，列表可以使用下标修改表中数据
my_list2[2] = 8
print(my_list2) # [1, 3, 8, 'hello', 3.14, 'nun', 'tedu']
my_list2[-1] = "tedu.com"
print(my_list2) # [1, 3, 8, 'hello', 3.14, 'nun', 'tedu']

2.列表的遍历

# 列表的遍历
my_list = ["易烊千玺","薛之谦","肖战","朱茵","舒淇"]
for i in my_list: # i 就代表列表中每一个数据
    print(i)
​
print("*" * 20)
j = 0
while j < len(my_list)：
    print(my_list[j])
    j = j +1

3. 列表的添加

3.1.向列表中添加数据的方法，都是直接在原列表上进行添加，不会返回新列表

#1.append() 直接尾部添加
#列表.append(数据)，像尾部追加数据
my_list = ["易烊千玺","薛之谦","肖战","朱茵","舒淇"]
my_list.append("xcq")
print(my_list) # ['易烊千玺', '薛之谦', '肖战', '朱茵', '舒淇', 'xcq']

3.2.insert()元素往后挪 插入数据后面的元素的下标依次后移1位

#列表.insert(下标，数据) 在指定位置下标进行添加数据
my_list.insert(2,"jiyu")
print(my_list) # ['易烊千玺', '薛之谦', 'jiyu', '肖战', '朱茵', '舒淇', 'xcq']

3.3.extend() 一般没人用

#列表.extend(可迭代对象) #str,列表 会将迭代对象中的数据逐个添加到原有列表的末尾
my_list.extend("yud")
print(my_list) #['易烊千玺', '薛之谦','jiyu', '肖战','朱茵','舒淇','xcq','y','u','d']
my_list.extend([1,2,"zz"])
print(my_list) 
#['易烊千玺','薛之谦','jiyu','肖战','朱茵', '舒淇', 'xcq', 'y', 'u', 'd', 1, 2, 'zz']

4. 列表中数据的查询

4.1.index() 根据数据值，查找元素所在的下标，找到则返回元素的下标，没有找到则程序报错

my_list = ["易烊千玺","薛之谦","肖战","朱茵","舒淇"]
#查找 肖战 在列表中的元素下标
num = my_list.index("肖战")
print(num) #2

4.2.count 统计列表中的指定元素出现的次数

num = my_list.count("肖战")
print(num) #1

4.3.in / not in 判断是否存在 如果存在True 不存在false 一般与if饥饿和使用

str1 = "肖战" in my_list
print(str1) #True
​
str1 = "肖战" not in my_list
print(str1) #false

5. 列表元素的删除

5.1 根据元素的数据值进行删除

# remove(数据) 直接删除原列表中的数据
my_list.remove(11)
print(my_list)
# my_list.remove(11)
# print(my_list) # 程序报错，要删除的元素必须在列表中

5.2 根据下标删除

# 列表.pop(下标) 默认删除最后一个数据，返回被删除的内容
num = my_list.pop(2)
print(num) #5
print(my_list) #[1, 3, 7, 9]
num1 = my_list.pop()
print(num1) #9

5.3 del 列表[下标]

del my_list[1]
print(my_list) #[1, 7]
​
del my_list[2]
print(my_list) # 删除不存在的下标元素则程序报错。

6.列表的排序和逆置

想要对列表中的数据进行排序，前提是列表中的数据类型是一样的

6.1 sort（） 直接在原列表上进行改变

• 默认是升序，从小到大

• 列表.sort()

my_list = [1, 3, 4, 5, 89, 43, 1, 4]
my_list.sort()
print(my_list) # [1, 1, 3, 4, 4, 5, 43, 89]

• 降序 从大到小排序

• 列表.sort(reverse=True)

my_list.sort(reverse=True)
print(my_list) #[89, 43, 5, 4, 4, 3, 1, 1]

6.3 sorted ( ) 新列表里面改变

• 默认是升序，从小到大

• 列表.sorted()

  my_list1 = sorted(my_list)
  print(my_list1) #[1, 1, 3, 4, 4, 5, 43, 89]

• 降序 从大到小排序

• 列表.sorted(reverse=True)

  my_list2 = sorted(my_list,reverse=True)
  print(my_list2) #[89, 43, 5, 4, 4, 3, 1, 1]

  6.4 用切片逆置

  my_list3 = ["a","b","c","d","f"]
  my_list4 = my_list3[::-1]
  print(my_list3) #['a', 'b', 'c', 'd', 'f']
  print(my_list4) #['f', 'd', 'c', 'b', 'a']

7. 列表的嵌套

#列表的嵌套
school_name = [
            ["清华大学", "北京大学"],
            ["复旦大学", "厦门大学"],
            ["西安交大", "上海交大"],
            ["南京大学", "宁夏大学"],
            ]
print(school_name[1]) #['复旦大学', '厦门大学']
print(school_name[3][1]) #宁夏大学
#  遍历
for schools in school_name:
    #print(schools) #列表
    for name in schools:
        print(name)#清华大学北京大学复旦大学厦门大学西安交大上海交大南京大学宁夏大学

8列表的推导式

8.1使用简易方法，将可迭代对象转换为列表

8.2语法：

#语法：
#变量 = [b表达式 for 变量 in 可迭代对象 ]
#变量 = [b表达式 for 变量 in 可迭代对象  if 条件]
# 说明：
# 如果If 真值表达式的布尔值为false ，则可迭代对象生成的数据被丢失

8.3需求1：在my_list中挑出能被3整除的数字存入my_list01

my_list01 =[]
for num in my_list:
    if num % 3 == 0:
        my_list01.append(num)
print(my_list01) #[9, 15, 6, 78]
#上述写法等价于下：
# my_list02 = [num for num in my_list if num % 3 == 0]
# print(my_list02) #[9, 15, 6, 78]

8.4 需求2：在my_list 中所有数字的个位存储到my_list03中

my_list03 = []
for num in my_list:
    my_list03.append(num % 10)
    print(my_list03) #[9, 5, 5, 6, 8, 9]
#上述写法等价于用列表：  
my_list03 = [num %10 for num in my_list]
print(my_list03) #[9, 5, 5, 6, 8, 9]

十、元组

1.元组的定义

1.1定义

• 由一系列变量组成的不可变序列容器

• 不可变是指一旦创建，不可再添加/删除/修改元素

• 元组与列表非常相似，都可以存放多个数据，可以存放不同数据类型的数据

• 不同点：列表使用[] 定义，元组使用()定义

2.元组的创建

2.1 创建空元组

元组名 = ()
元组名 =tuple()

2.2 创建非空元组

 元组名 =(20)
 元组名 =(1,2,3)
 元组名 =100,200,300
 元组名 =tuple(可迭代对象)
#元组名 = (元素1，元素2，元素3)
tuple01 = (10,20,"nun")
print(tuple01,type(tuple01))
#元组名 = tuple(可迭代对象)
tuple02 = tuple(["a","b""c"])
print(tuple02,type(tuple02))

3. 元组的遍历

3.1 获取元组

• 变量 = 元组名[索引]

• 变量 = 元组名[切片] #赋值给变量的切片所创建的新列表

  #读取元素(索引/切片)
  print(tuple01[1]) #20
  print(tuple01[:2]) #(10, 20)

  3.2 遍历元组

• 正向遍历

    for 变量名 in 列表名:
           变量名就是元素
              
  for item in tuple01:
      print(item)

• 反向遍历

for 索引名 in range (len (列表名)-1，-1，-1):
         元组名[索引名]就是元素
        
for i in range(len(tuple01) - 1,-1,-1):
    print(i)
    print(tuple01[i])

4.特殊

4.1 注意1—小括号可以省略

tuple03 = 10,20,30,"tedu"
print(tuple03) #(10, 20, 30, 'tedu')

4.2 如果元组中只有一个元素，必须要有逗号

tuple04 = (10,)
print(tuple04) #(10,)

4.3 拆包 ： 多个变量 = 容器

#tuple03里面有几个值 对应的前面就有几个变量
a,b,c ,d= tuple03
print(a,b,c,d) #10 20 30 tedu
a,b,c = "孙悟空"
print(a,b,c) #孙 悟 空
*a,b = "薛之谦"  # *号代表double
print(a) #['薛', '之']
print(b) #谦

十一、字典

1.字典的定义

• 字典dict 定义使用后{ } 定义，是由键值对组成（key - value)

• 变量 = {key1:value1,key2:value2,key3,value3,...}

• 字典的key可以是字符串类型和数字类型（int,float) 不能是列表

  my_dict ={}
  my_dict1 = dict{}
  print(my_dict,type(my_dict))
  print(my_dict1,type(my_dict1))

  1.2定义带数据的字典

  my_dict2 = {"name":"习春琼","age":19,"sex":"女","hobby":["学习","看书","音乐"],1:[2,5,8]}
  print(my_dict2) #{'name': '习春琼', 'age': 19, 'sex': '女', 'hobby': ['学习', '看书', '音乐'], 1: [2, 5, 8]}

  2.访问 value 的值

  在字典中没有下标的概念，使用key值访问对应的value 的值

#访问年龄
print(my_dict2["age"]) #19
​
#访问hobby中的学习
print(my_dict2["hobby"][0]) #学习
​
#如果 key 值不存在，代码会报错
#print(my_dict2["like"]) #KeyError: 'like'
​
# 字典.get(key) 如果key值不存在，不会报错，返回的是None
print(my_dict2.get("like")) #None
# 字典.get(key,数据值) 如果key存在，则返回key对应的value值，如果key不存在，则返回书写的数据值
print(my_dict2.get("gender","男呀")) #男呀
print(my_dict2.get("age",1)) #19

3. 获取字典的长度

print(len(my_dict2)) #5

4. 添加和修改

4.1字典的添加和修改数据，使用Key值进行添加和修改

4.2字典[key] = 数据值 如果key值存在，就是修改，如果key不存在，就是添加

my_dict ={"name":"tedu"}
print(my_dict) #{'name': 'tedu'}
my_dict["age"] = 18 # key值存在，则添加
print(my_dict) #{'name': 'tedu', 'age': 18}
​
my_dict["name"] = "达内" #key值存在则修改
print(my_dict) #{'name': '达内', 'age': 18}

• 注意 key 值int的1 和float的1.0 代表同一个key值

  my_dict[1] = "int" #{'name': '达内', 'age': 18, 1: 'int'}
  print(my_dict)
  ​
  my_dict[1.0] = "float"
  print(my_dict) #{'name': '达内', 'age': 18, 1: 'float'}

5. 删除

根据 key 值删除数据

• del字典名[key]

del my_dict[1]
print(my_dict) #{'name': '习春琼', 'age': 19, 'sex': '女', 2: 'aa'}

• 字典.pop（key)

  根据key清楚，返回值是被删除的key 对应的value 值

  result  = my_dict.pop(2)
  print(result)#aa
  print(my_dict) #{'name': '习春琼', 'age': 19, 'sex': '女'}

• 字典.clear( )

  清空字典，删除所有的键值对

  my_dict.clear();
  print(my_dict) #{}

• del 字典名

  直接将这个字典删除，不能在使用这个字典了

  del my_dict # 后边就不能在使用这个变量了，除非再次定义
  print(my_dict)# 代码报错，变量未定义

6.遍历数据

6.1 for 循环

直接遍历字典，直接遍历字典的key值

my_dict ={ 'name': '习春琼', 'age': 19, 'sex': '女', 2: 'aa'}
for key in my_dict:
    print(key,my_dict[key])

6.2 字典.keys()

获取字典中所有的key值，返回的类型是dict_keys，该类型具有的特点是：

1. 可以使用list() 进行类型转换，即将当前字典转换为列表类型。

2. 可以用for循环遍历

result = my_dict.keys()
print(result,type(result))
for key in result:
    print(key)

6.3 字典.values()

获取所有的values值，类型是dict_values

1. 字典可以用list() 进行类型转换，将其转换为列表类型

2. 使用for 循环遍历

result1 = my_dict.values()
print(result1,type(result1))
for value in result1:
    print(value)

6.4 字典.items()

获取所有的键值对，类型是dict_items,key,value组成元组类型

1. 可以用list() 进行类型转换，即当前字典转换为列表类型

2. 使用for循环遍历

result2 = my_dict.items()
print(result2,type(result2))
for item in result2:
    print(item[0],item[1])

十二、函数

1.函数的定义

1.1 函数：能够实现具体功能，是多行代码整个 函数的定义：是用关键字def def 函数名(): # 函数名要遵循标识符的命名规则，见名知义 函数代码(函数体) 函数定义，函数中的代码不会执行，在调用函数的时候，才会执行 函数的好处：重复的代码不需要多次书写，减少代码冗余

def func():
    print("习春琼要好好学习！")
    print("要早点去见想见的人啊.")
​
# 函数调用 ：函数名 ()
func() # 代码会跳转到函数定义的地方去执行

2 函数的文档说明

2.1 函数的文档说明本质上就是注释，告诉别人，这个函数怎么使用，是干什么事的

2.2 查看函数的文档注释可以使用help(函数名)

def func():
    '''
    这个函数就是为了打印输出hello Python 的
    :return:
    '''
    # aaa
    print("hello python")
    func()
help(print)

3.编写带参数函数

3.1 函数带参数可以使代码更加通用，适用于多场景

#定义函数
def add(a,b): # a 和 b成为形式参数 也叫形参 函数定义时候的参数
    # a = 20
    # b = 10
    c = a + b
    print(f"求和的结果是{c}")
​
# 函数调用
# 如果函数在定义时有形参，那么在函数调用时，必须传递参数值
# 这个参数叫实际参数，也叫实参
#函数调用时，会将实参传递给形参
#形参个数和实参个数对应，相同，不能多不能少。
add(100,3000)
add(1,2)

4.enumerate 函数

my_list = ["a","b","c","d","e"]
for i in my_list:
    print(i)
​
for i in my_list:
    print(my_list.index(i),i) # 下标与元素值
​
print("*" * 30)
#enumerate 函数 将可迭代序列中元素所在的下标和具体的元素谁结合在一起，变成元组
for j in enumerate(my_list):
    print(j)

十三、公共方法

 + 支持字符串、列表、元组进行操作，得到一个新容器
 * 整数 赋值，支持字符串，列表，元组进行操作
in/not in 判断存在或者不存在，支持字符串，列表，元组。字典进行操作。
 注意：如果字典的话，判断是key的值是否存在或者不存在
min/max 对于字典来说，比较的是字典的key的值的大小
my_dict ={"a":10,"b":20,"c":30}
print(max(my_dict)) #c
print(min(my_dict)) #a
13.2列表，元组，可以存放任意

数据类型，同样，字典中的value也可以是任意类型，字典也可以作为字典的value值

my_dict2 = {"name":"习春琼","age":19,"sex":"女","hobby":["学习","看书","音乐"],1:{"a":1,"b":2}}
print(my_dict2[1]["b"]) #2
​
my_list =[{},{},my_dict2]
print(my_list)

十四、变量

1. 局部变量

局部变量的作用域:当前函数内部 局部变量的生命周期：在函数调用时被创建，在函数调用结束之后被销毁 局部变量只能在当前函数的内部使用，不能再函数外部使用

def func():
    num = 100
    print(num)
​
def func1():
    num = 200 #此处num 和 上面的　num　是没有关系的
    print(num)
​
func()
func1()
​
# print(num) # 报错，局部变量在函数外部不能使用

2.全局变量

全局变量：定义在函数外部的变量

在函数内部也可以访问全局变量的值，如果想要修改全局变量的值，需要用global声明

num = 100
def func():
    print(num)
​
def func1():
   # num = 200 #这里不是修改全局变量的值，而是重新定义了一个局部变量，和全局变量的名字一样而已
   global num # 如果想要修改全局变量的值，需要使用global关键字声明
   num = 300
print(num)
​
def func2():
    print(num)
#调用函数
func()
func1()
func2()

3.return 关键字

在函数定义的局部变量，或者通过计算机的出的局部变量，想要在函数外部访问和使用 此时就可与使用return 关键字,将这个返回值返回。

return关键字的作用： 1.将return 后的数据值进行返回 2.程序代码遇到return 会终止（结束）执行 注意： return 关键字 碧玺卸载函数中

def add(a,b):
    c = a + b
    return c
# print(f"求和结果为{c}") #程序代码遇到return 会终止（结束）执行
​
​
#return 返回多个数据值
def func1(a,b):
    c = a + b
    d = a - b
   # return [c,d] #[300, -100]
   #return (c,d)  #(300, -100)
    #return {"c":c,"d":d} #{'c': 300, 'd': -100}
    return c,d # 默认是组成元组进行返回
​
# return 关键字后买你可以不屑数值
def func2():
    print("jello world")
    return   #返回None 终止函数运行
​
#函数可以不写return  返回默认值None
def func3():
    print("hello xcq")
    pass
# 调用函数
result = add(100,300)
print(f"函数外部获得求和结果{result}")
​
print("*" * 30 )
​
result1 = func1(100,200)
print(result1) #[300, -100]
​
result2 = func2()
print(result2)
result3 = func3()
print(result3)

4. 函数的嵌套使用

def func1():
    print("func1 start...")
    print("函数其他代码")
    print("func1 end ...")
​
def func2():
    print("func2 start...")
    func1() # 调用函数
    print("func2 end ...")
​
# 调用函数
# func1()
func2()