python基础

2021/04/07 14:57:38

python入门手册


前言

本文章用于记录自己的python学习笔记


提示:以下是本篇文章正文内容,下面案例可供参考

一、Python的介绍

1.python是一个免费、开源、跨平台、动态、面向对象的编程语言。
2.python的执行方式分为交互式和文件式
3.python的执行过程:源代码 – 编译 --> 字节码 – 解释 --> 机器码

二、数据基本运算

1.注释

1.单行注释:以#号开头。
2.多行注释:三引号开头,三引号结尾。

2.函数

表示一个功能,函数定义者是提供功能的人,函数调用者是使用功能的人。
例如:
1.print(数据) 作用:将括号中的内容显示在控制台中
2.变量 = input(“需要显示的内容”) 作用:将用户输入的内容赋值给变量。

3.变量

必须是字母或下划线开头,后跟字母、数字、下划线。字母小写,多个单词以下划线隔开。
语法:变量名 = 数据
变量名1 = 变量名2 = 数据
变量名1, 变量名2, = 数据1, 数据2
下面展示一些 例子

name = "赵敏"
a01 = a02 = "周芷若"
b01, b02 = "苏大强", "苏明玉"

4.del语句

1.语法:
del 变量名1, 变量名2
2.作用:
用于删除变量,同时解除与对象的关联.如果可能则释放对象。
3.自动化内存管理的引用计数:
每个对象记录被变量绑定(引用)的数量,当为0时被销毁。

5.空值对象None

1.表示不存在的特殊对象。
2.作用:占位和解除与对象的关联。

6.整形int

表示整数,涉及知识有进制之间的转换。
小整数对象池:CPython 中整数 -5 至 256,永远存在小整数对象池中,不会被释放并可重复使用。

7.浮点数float

表示小数,科学计数法

8.字符串str

9.布尔值bool

真为True,本质是1;假为False,本质是0
取值:(真,对的,满足条件)True (假,错的,不满足条件)False

10.数据类型转换

1.转换为整形: int(数据)
2.转换为浮点型:float(数据)
3.转换为字符串:str(数据)
4.转换为布尔:bool(数据)
结果为False:bool(0) bool(0.0) bool(None)
5.混合类型自动升级:
1 + 2.14 返回的结果是 3.14
1 + 3.0 返回结果是: 4.0

三、运算符

1.算术运算符

加减乘除,地板除,取余,幂运算

2.增强运算符

例如:y += x 等同于 y = y + x
y -= x 等同于 y = y - x

3.比较运算符

< 小于
<= 小于等于
> 大于
>= 大于等于
== 等于
!= 不等于
返回布尔类型的值

4.逻辑运算符

与and
表示并且的关系,一假俱假。
或or
表示或者的关系,一真俱真
非 not
表示取反

5.身份运算符

语法:
x is y
x is not y
作用:
is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
is not 的作用与is相反
下面展示一些 身份运算符代码

//在文件式中为True,在交互式中为False
a = 800
c = a
print(id(a))
print(id(c))
print(c is a)
//在小数对象池中不会被释放可以重复利用,在交互中也为True

三.语句

1.行

1.物理行:程序员编写代码的行。
2.逻辑行:python解释器需要执行的指令。
3.建议一个逻辑行在一个物理行上。
4.如果一个物理行中使用多个逻辑行,需要使用分号;隔开。
5. 如果逻辑行过长,可以使用隐式换行或显式换行。
隐式换行:所有括号的内容换行,称为隐式换行
括号包括: () [] {} 三种
显式换行:通过折行符 \ (反斜杠)换行,必须放在一行的末尾,目的是告诉解释器,下一行也是本行的语句。
下面展示一些

# 三个物理行,三个逻辑行
a = 1
b = a + 2
c = a + b

# 一个物理行,三个逻辑行(不建议) 一个物理行中有多个逻辑行用分号隔开
a = 1;b = a + 2;c = a + b

# 一个物理行,一个逻辑行
d = 1 + 2 +3 + 4
# 一个物理行,两个逻辑行
# \ 表示折行符 显式换行
d = 1 + 2 \
    +3 + 4

# 四个物理行,一个逻辑行 隐式换行:所有括号的内容换行
d = (1 +
     2 +
     3 +
     4)

2.选择语句

If elif else 语句

1.作用:
让程序根据条件选择性的执行语句。
2.语法:
if 条件1:
语句块1
elif 条件2:
语句块2
else:
语句块3
3.说明:
elif 子句可以有0个或多个。
else 子句可以有0个或1个,且只能放在if语句的最后。
具有独立性,如果前面条件满足,后续条件不再判断。
下面展示一些 选择语句的练习1

# 在控制台中录入一个数字,
# 再录入一个运算符(+ - * /),最后录入一个数字。
# 根据运算符,计算两个数字。
# 要求:如果运算符,不是加减乘除,则提示"运算符有误"

number_one = float(input("请输入第一个数字:"))
operator = input("请输入运算符:")
number_two = float(input("请输入第二个数字:"))
if operator == "+":
    print(number_one + number_two)
elif operator == "-":
    print(number_one - number_two)
elif operator == "*":
    print(number_one * number_two)
elif operator == "/":
    print(number_one / number_two)
else:
    print("运算符输入有误")

下面展示一些 选择语句练习2

"""
    在控制台中录入一个成绩,
    判断等级(优秀/良好/及格/不及格/输入有误)。
"""
if score > 100 or score < 0:
    print("输入有误")
elif 90 <= score:
    print("优秀")
elif 80 <= score:
    print("良好")
elif 60 <= score:
    print("及格")
else:
    print("不及格")

if 语句的真值表达式

if 100:
print(“真值”)
等同于
if bool(100):
print(“真值”)

条件表达式

语法:变量 = 结果1 if 条件 else 结果2
作用:根据条件(True/False) 来决定返回结果1还是结果2。
下面展示一些 条件表达式练习

year = int(input("请输入年份:"))
# if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
#     day = 29
# else:
#     day = 28
day = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
print(day)

3. 循环语句

while语句

1.作用:
可以让一段代码满足条件,重复执行。
2.语法:
while 条件:
满足条件执行的语句
else:
不满足条件执行的语句
3.说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
下面展示一些 while循环练习1

while True:
    usd = int(input("请输入美元:"))
    print(usd * 6.9)
    if input("输入q键退出:"):
        break  # 退出循环体

下面展示一些 while循环练习2

//计数
count = 0
while count < 3:  # 0  1  2
    count += 1
    usd = int(input("请输入美元:"))
    print(usd * 6.9)

下面展示一些 条件语句和循环语句的练习1

"""
    练习:猜数字游戏
    游戏运行产生一个1--100之间的随机数。
    让玩家重复猜测,直到猜对为止。
    提示:大了
       小了
        猜对了,总共猜了多少次
"""
import random
number=random.randint(1,100)
count=0
while True:
    guess_number = int(input("请输入一个数字"))
    count+=1
    if guess_number>number:
        print("猜大了")
    elif guess_number<number:
        print("猜小了")
    else:
        print("猜对了,总共猜了"+str(count))

下面展示一些 条件语句和循环语句练习2

# 练习:循环根据成绩判断等级,如果录入空字符串则退出程序.
# 如果成绩录入错误次数达到3.则退出成绩并提示"成绩错误过多"
count = 0
while count<3:
    str_score = input("请输入成绩:")
    if str_score == "":
        break# 不会执行else语句
    score = int(str_score)
    if score > 100 or score < 0:
        print("输入有误")
        count += 1
    elif 90 <= score:
        print("优秀")
    elif 80 <= score:
        print("良好")
    elif 60 <= score:
        print("及格")
    else:
        print("不及格")
else:
    print("成绩错误过多")

for语句

1.作用:
用来遍历可迭代对象的数据元素。
可迭代对象是指能依次获取数据元素的对象,例如:容器类型。
2.语法:
for 变量列表 in 可迭代对象:
语句块1
else:
语句块2
3.说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
for: 适合执行预定次数。
while:适合根据条件循环执行。

下面展示一些 for循环的练习

import random
score = 0
for item in range(3):
    random_number01 = random.randint(1, 10)
    random_number02 = random.randint(1, 10)
    input_number = int(input("请输入" + str(random_number01) + "+" + str(random_number02) + "=?"))
    if input_number == random_number01 + random_number02:
        score += 10
print("总分:" + str(score))

range函数

1.作用:
用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)。
2.语法:
range(开始点,结束点,间隔)
3.说明:
函数返回的可迭代对象可以用for取出其中的元素
返回的数字不包含结束点
开始点默认为0
间隔默认值为1
下面展示一些 range练习

# 练习1:累加1--100的和  1+2+3+..+100
sum = 0
for item in range(1,101,1):
    sum+=item
print(sum)

# 练习2:累加1--100之间偶数和  2+4+6+8+...+100
sum=0
for item in range(2,100,2):
    sum+=item
print(sum)

# 练习3:累加10--36之间的和
sum_value = 0
for item in range(10,37):
    sum_value += item
print(sum_value)

4.跳转语句

break语句

1.跳出循环体,后面的代码不再执行。
2.可以让while语句的else部分不执行。

下面展示一些 break语句的练习

# 在控制台中获取一个整数,判断是否为素数。
number=int(input("请输入一个整数:"))
if number<=1:
    print('不是素数')
else:
    for item in range(2,number,1):
        if number%item==0:
            print("不是素数")
            break# 如果发现满足条件的数字,就不再判断后面的了。
    else:
        print("是素数")

continue语句

跳过本次,继续下次循环。
下面展示一些 continue练习

# 累加10-50之间个位不是2,5,9的整数.
sum_value = 0
for item in range(10, 51):
    unit = item % 10
    # 个位是2,5,9的整数 则 跳过.
    if unit == 2 or unit == 5 or unit == 9:
        continue
    sum_value += item

print(sum_value)

四.容器类型

1.通用操作

数学运算符

1.+:用于拼接两个容器
2.+=:用原容器与右侧容器拼接,并重新绑定变量
3.*:重复生成容器元素
4.*=:用原容器生成重复元素, 并重新绑定变量
< <= > >= == !=:依次比较两个容器中元素,一但不同则返回比较结果。

成员运算符

1.语法:
数据 in 序列
数据 not in 序列
2.作用:
如果在指定的序列中找到值,返回bool类型。

索引index

1.作用:访问容器元素
2.语法:容器[整数]
3.说明:
正向索引从0开始,第二个索引为1,最后一个为len(s)-1。
反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。

切片slice

1.作用:
从容器中取出相应的元素重新组成一个容器。
2.语法:
容器[(开始索引):(结束索引)(:(步长))]
3.说明:
小括号()括起的部分代表可省略
结束索引不包含该位置元素
步长是切片每次获取完当前元素后移动的偏移量
下面展示一些 切片代码练习

# 练习:在控制台中获取一个字符串
# 打印第一个字符
# 打印最后一个字符
# 打印倒数第三个字符
# 打印前两个字符
# 倒序打印字符
# 如果字符串长度是奇数,则打印中间字符.
str01 = "我叫齐天大圣."
print(str01[0])
print(str01[-1])
print(str01[-3])
print(str01[0:2])
print(str01[::-1])
if len(str01)%2==1:
    print(str01[(len(str01)//2)])

内置函数

1.len(x) 返回序列的长度
2.max(x) 返回序列的最大值元素
3.min(x) 返回序列的最小值元素
4.sum(x) 返回序列中所有元素的和(元素必须是数值类型)

2.字符串

由一系列字符组成的不可变序列容器,存储的是字符的编码值。

编码

1.字节byte:计算机最小存储单位,等于8 位bit.
2.字符:单个的数字,文字与符号。
3.字符集(码表):存储字符与二进制序列的对应关系。
4.编码:将字符转换为对应的二进制序列的过程。
5.解码:将二进制序列转换为对应的字符的过程。
6.编码方式:
–ASCII编码:包含英文、数字等字符,每个字符1个字节。
–GBK编码:兼容ASCII编码,包含21003个中文;英文1个字节,汉字2个字节。
–Unicode字符集:国际统一编码,旧字符集每个字符2字节,新字符集4字节。
– UTF-8编码:Unicode的存储与传输方式,英文1字节,中文3字节。

相关函数

1.ord(字符串):返回该字符串的Unicode码。
字 --> 数
2.chr(整数):返回该整数对应的字符串。
数 --> 字

字面值

单引和双引号的区别
1.单引号内的双引号不算结束符
2.双引号内的单引号不算结束符
三引号作用
1.换行会自动转换为换行符\n
2.三引号内可以包含单引号和双引号
3.作为文档字符串
转义字符
1.改变字符的原始含义。
\’ \” \””” \n \ \t \0 空字符
2.原始字符串:取消转义。
a = r”C:\newfile\test.py”
字符串格式化
1.定义:
生成一定格式的字符串。
2.语法:
字符串%(变量)
“我的名字是%s,年龄是%s” % (name, age)
3.类型码:
%s 字符串 %d整数 %f 浮点数 %.1f保留一位小数

3.列表

由一系列变量组成的可变序列容器
1.创建列表:
列表名 = []
列表名 = list(可迭代对象)
2.添加元素:
列表名.append(元素)
列表.insert(索引,元素)
下面展示一些 列表的练习1

"""
    在控制台中录入,西游记中你喜欢的人物.
    输入空字符串,打印(一行一个)所有人物.
"""

list_person = []
# 录入过程
while True:
    str_input = input("输入在西游记中喜欢的人物:")
    if str_input == "":
        break
    list_person.append(str_input)

# 输出过程
for item in list_person:
    print(item)

3.定位元素:
索引、切片
下面展示一些 列表的练习2

"""
# 在控制台中录入,所有学生姓名.
# 如果姓名重复,则提示"姓名已经存在",不添加到列表中.
# 如果录入空字符串,则倒叙打印所有学生.
"""

list_name = []
while True:
    name = input("请输入姓名:")
    if name == "":
        break
    # 判断变量在列表中是否存在
    if name not in list_name:
        list_name.append(name)
    else:
        print("姓名已经存在")

# -1  -2  -3
# 2  1   0
for item in range(-1, -len(list_name) - 1, -1):
    print(list_name[item])

通过切片拿元素会重新创建列表
4.遍历列表:
正向:
for 变量名 in 列表名:
变量名就是元素
反向:
for 索引名 in range(len(列表名)-1,-1,-1):
列表名[索引名]就是元素
5.删除元素:
列表名.remove(元素)
del 列表名[索引或切片]
下面展示一些 列表的练习3

# 练习4:在列表中[9, 25, 12, 8],删除大于10的数字.
list01 = [9, 25, 12, 8]
# for item in list01:
#     if item > 10:
#         list01.remove(item)
**#删除元素,后一个会替换前一个**
#3 2  1 0
#-1 -2 -3 -4
for i in range(len(list01)-1,-1,-1):
    if list01[i] > 10:
        list01.remove(list01[i])
print(list01)

6.深拷贝和浅拷贝
浅拷贝:复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
list02 = list01.copy()等效于list02 = list01[:]
深拷贝:复制整个依赖的变量。
下面展示一些 深拷贝案例

import copy

list01 = [800,[1000,500]]
# 深拷贝
list02 =copy.deepcopy(list01)
list01[1][0] = 900
print(list02[1][0])#?

列表VS字符串
1.列表和字符串都是序列,元素之间有先后顺序关系。
2.字符串是不可变的序列,列表是可变的序列。
3.字符串中每个元素只能存储字符,而列表可以存储任意类型。
4.列表和字符串都是可迭代对象。
5.函数:
list–>str result = “连接符”.join(列表)
str --> list 列表 = “a-b-c-d”.split(“分隔符”)
下面展示一些 字符串列表转换练习

# 练习:英文单词翻转
# "How are you" -->"you are How"
str01 = "How are you"
list_temp = str01.split(" ")
str_result = " ".join(list_temp[::-1])
print(str_result)

列表推导式
1.定义:
使用简易方法,将可迭代对象转换为列表。
2.语法:
变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件]
下面展示一些 列表推导式案例

# 将list01中大于10元素,增加1以后存入list02中.
# list02 = []
# for item in list01:
#     if item >10:
#         list02.append(item + 1)
list02 = [item + 1 for item in list01 if item > 10]

3.说明:
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。

4.元组 tuple

由一系列变量组成的不可变序列容器。
1.创建空元组
元组名 = ()
元组名 = tuple()
2.创建非空元组:
元组名 = (20,)
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象)
3.获取元素:
索引、切片
4.遍历元组:
正向:
for 变量名 in 列表名:
变量名就是元素
反向:
for 索引名 in range(len(列表名)-1,-1,-1):
元祖名[索引名]就是元素
5.列表与元组的互相转换
下面展示一些 内联代码片

# 列表 --> 元组
tuple01 = tuple(["a", "b"])
print(tuple01)
# 元组 --> 列表
list01 = list(tuple01)
print(list01)

作用
1.元组与列表都可以存储一系列变量,由于列表会预留内存空间,所以可以增加元素。
2.元组会按需分配内存,所以如果变量数量固定,建议使用元组,因为占用空间更小。
3.应用:
变量交换的本质就是创建元组:x, y = y, x
格式化字符串的本质就是创建元祖:“姓名:%s, 年龄:%d” % (“tarena”, 15)
下面展示一些 元组练习

"""
    练习:在控制台中录入日期(月日),计算这是这一年的第几天.
    例如:3月5日
         1月天数 + 2月天数 + 5

         5月8日
         1月天数 + 2月天数 +3月天数 + 4月天数+ 8
"""
day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
month = int(input("请输入月份"))
day = int(input("请输入日:"))
# 方法一:
# # 累加前几个月天数
total_day = 0
for i in range(month - 1):
    total_day += day_of_month[i]
# 累加当月天数
total_day += day
print("是这年的第%d天." % total_day)

# 方法二:
# 累加前几个月天数
total_day = sum(day_of_month[:month - 1])
total_day += day
print("是这年的第%d天." % total_day)

5.字典 dict

1.由一系列键值对组成的可变映射容器。
2.映射:一对一的对应关系,且每条记录无序。
3.键必须惟一且不可变(字符串/数字/元组),值没有限制。
基础操作
1.创建字典:
字典名 = {键1:值1,键2:值2}
字典名 = dict (可迭代对象)
#默认值
dict01 = {“wj”:100,“zm”:80,“zr”:90}
dict01 = dict([(“a”,“b”),(“c”,“d”)])
print(dict01)
2.添加/修改元素:
语法:
字典名[键] = 数据
说明:
键不存在,创建记录。
键存在,修改映射关系。
3.获取元素: 要用if语句判断是否存在
变量 = 字典名[键] # 没有键则错误

4.遍历字典:
for 键名 in 字典名:
字典名[键名]
for 键名,值名 in 字典名.items():
语句
下面展示一些 遍历字典的练习

# 遍历字典,获取key
for key in dict01:
    print(key)
    print(dict01[key])

# 遍历字典,获取value
for value in dict01.values():
    print(value)

# 遍历字典,获取键值对key value(元组).
# for item in dict01.items():
#     print(item[0])
#     print(item[1])

for k,v in dict01.items():
    print(k)
    print(v)

5.删除元素:
del 字典名[键]
下面展示一些 字典练习1

# 在控制台中循环录入学生信息(姓名,年龄,成绩,性别).
#    如果名称输入空字符, 则停止录入.
# 将所有信息逐行打印出来.
#字典内嵌列表:
{
    "张无忌":[28,100,"男"],
}
"""
dict01={}
while True:
    name=input("请输入姓名:")
    if name=="":
        break
    age = int(input("请输入年龄:"))
    score=float(input("请输入成绩:"))
    sex=input("请输入性别")
    dict01[name]=[age,score,sex]
for name,list_info in dict01.items():
    print("%s的年龄是%d,成绩是%d,性别是%s"%(name,list_info[0],list_info[1],list_info[2]))

下面展示一些 字典练习2

"""
# 字典内嵌字典:
{
    "张无忌":{"age":28,"score":100,"sex":"男"},
}
"""
dict_student_info = {}
while True:
    name = input("请输入姓名:")
    if name == "":
        break
    age = int(input("请输入年龄:"))
    score = int(input("请输入成绩:"))
    sex = input("请输入性别:")
    dict_student_info[name] = {"age": age, "score": score, "sex": sex}

for name, dict_info in dict_student_info.items():
    print("%s的年龄是%d,成绩是%d,性别是%s" %
          (name, dict_info["age"],
           dict_info["score"], dict_info["sex"]))

下面展示一些 字典练习3

"""
# 列表内嵌字典:
[
    {"name":"张无忌","age":28,"score":100,"sex":"男"},
]

"""
list_student_info = []
while True:
    name = input("请输入姓名:")
    if name == "":
        break
    age = int(input("请输入年龄:"))
    score = int(input("请输入成绩:"))
    sex = input("请输入性别:")
    dict_student_info={'name':name,"age": age, "score": score, "sex": sex}
    list_student_info.append(dict_student_info)
for dict_student_info in list_student_info:
    print("%s的年龄是%d,成绩是%d,性别是%s" % (dict_student_info["name"], dict_student_info["age"], dict_student_info["score"], dict_student_info["sex"]))
# 获取第一个学生信息
dict_info = list_student_info[0]
print("第一个录入的是:%s,年龄是%d,成绩是%d,性别是%s" % (dict_info["name"], dict_info["age"], dict_info["score"], dict_info["sex"]))

选择策略:根据具体需求,结合优缺点,综合考虑(两害相权取其轻).
字典:
优点:根据键获取值,读取速度快;
   代码可读性相对列表更高(根据键获取与根据索引获取).
缺点:内存占用大;
   获取值只能根据键,不灵活.
列表:
优点:根据索引/切片,获取元素更灵活.
相比字典占内存更小。
缺点:通过索引获取,如果信息较多,可读性不高.
字典 VS 列表
1.都是可变容器。
2.获取元素方式不同,列表用索引,字典用键。
3.字典的插入,删除,修改的速度快于列表。
列表的存储是有序的,字典的存储是无序的。
下面展示一些 扩展练习

"""
计算一个字符串中的字符以及出现的次数.
# 思想:
# 逐一判断字符出现的次数.
# 如果统计过则增加1,如果没统计过则等于1.

abcdefce
a 1
b 1
c 2
d 1
e 2
f 1
"""

dict_result = {}
str_target = "abcdefce"
for item in str_target:
    if item not in dict_result:
        dict_result[item] = 1
    else:
        dict_result[item] += 1

print(dict_result)

字典推导式
1.定义:
使用简易方法,将可迭代对象转换为字典。
2.语法:
{键:值 for 变量 in 可迭代对象}
{键:值 for 变量 in 可迭代对象 if 条件}
下面展示一些 字典推导式练习1

#["无忌","赵敏","周芷若"] ->{"无忌":2,"赵敏":2,"周芷若":3}
list_name=["无忌","赵敏","周芷若"]
dic_name={}
for item in list_name:
    dic_name[item]=len(item)
print(dic_name)
dic_name={item:len(item) for item in list_name}
print(dic_name)

下面展示一些 字典推导式练习2

# 练习2:["无忌","赵敏","周芷若"]  [101,102,103]
#  {"无忌":101,"赵敏":102,"周芷若":103}
list01=["无忌","赵敏","周芷若"]
list02=[101,102,103]
dict01={}
#通过索引同时在多个列表中获取元素
for i in range(len(list01)):
    dict01[list01[i]]=list02[i]
print(dict01)

# 需求:字典如何根据value查找key
# 解决方案1:键值互换
dict02 = {value: key for key, value in dict01.items()}
print(dict02)
print(dict02[101])
# 缺点:因为键不能重复而值可以重复,所以如果key重复,交换或则丢失数据。
# 如果需要保持所有数据
# [(k,v),]
list02 = [(value, key) for key, value in dict01.items()]
print(list02)

6.集合

1.由一系列不重复的不可变类型变量组成的可变映射容器。
2.相当于只有键没有值的字典(键则是集合的数据)。
基础操作
1.创建空集合:
集合名 = set()
集合名 = set(可迭代对象)
set01 = set()
set --> str
set01 = set(“abcac”)
集合变列表
list01 = list(set01)
列表变字符串
str01 = “”.join(list01)
print(str01) # “bca”
2.创建具有默认值集合:
集合名 = {1, 2, 3}
集合名 = set(可迭代对象)
3.添加元素:
集合名.add(元素)
4.删除元素:
集合名.discard(元素)
运算
1.交集&:返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}

2.并集:返回不重复元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}

3.补集-:返回只属于其中之一的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} 属于s1但不属于s2

补集^:返回不同的的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)

4.子集<:判断一个集合的所有元素是否完全在另一个集合中
5.超集>:判断一个集合是否具有另一个集合的所有元素
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True
s1 > s2 # True

6.相同或不同== !=:判断集合中的所有元素是否和另一个集合相同。
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
s1 != s2 # False
子集或相同,超集或相同 <= >=
固定集合 frozenset
定义
不可变的集合。
作用
固定集合可以作为字典的键,还可以作为集合的值。
基础操作
创建固定集合:frozenset(可迭代对象)
运算
等同于set

扩展 for for循环

下面展示一些 双层循环练习1

# 列表排序(升序小 -->  大)
list01 = [3, 80, 45, 5, 7, 1]
for r in range(len(list01) - 1):
    # 作比较
    for c in range(r + 1, len(list01)):
        # list01[2]  list01[c]
        if list01[r] > list01[c]:
            list01[r], list01[c] = list01[c], list01[r]

print(list01)

下面展示一些 双层循环练习2

判断列表中元素是否具有相同的[3,80,45,5,80,1]
    思路:所有元素俩俩比较,发现相同的则打印结果
       所有元素比较结束,都没有发现相同项,则打印结果.
       #假设没有相同项
result=False
list01=[3,81,5,5,81,1]
for r in range(len(list01)-1):
    for c in range(r+1,len(list01)):
        if list01[r]==list01[c]:
            print('具有相同项')
            result=True
            break#只退了离他最近的一层循环
    if result:
        break
if result==False:
    print("没有相同项")

函数function

def 函数名(形式参数):
函数体
def 关键字:全称是define,意为”定义”。
函数名:对函数体中语句的描述,规则与变量名相同。(动词开头)
形式参数:方法定义者要求调用者提供的信息。
函数体:完成该功能的语句。
函数的第一行语句建议使用文档字符串描述函数的功能与参数。

调用函数

1.语法:函数名(实际参数)
2.说明:根据形参传递内容。
下面展示一些 函数练习

def print_rectangle(r_count,c_count,char):
    """
       打印矩形
    :param r_count: 行数
    :param c_count: 列数
    :param char: 填充字符
    :return: 
    """
    for r in range(r_count):
            # 内层循环控制列 
            for c in range(c_count):
                print(char, end=" ")
            print()

print_rectangle(3,4,"*")

返回值

1.定义:
方法定义者告诉调用者的结果。
2.语法:
return 数据
3.说明:
return后没有语句,相当于返回 None。
函数体没有return,相当于返回None。
参数:调用者传递给定义者的信息
返回值:定义者传递给调用者的结果

下面展示一些 返回值练习

# 定义函数,根据年月,计算有多少天。考虑闰年29天,平年28天
#当考虑闰年时
#不建议方法的返回值类型可能是多种,一般让返回的值为同类型,所以本代码将输入有误变成0
#由于一个函数只做一件事情所以判断闰年的应该提出去
def is_leap_year(year):
    return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
def get_day_by_month(month,year):
    if month < 1 or month > 12:
        return 0
    if month == 2:
        # if is_leap_year(year):
        #     return 29
        # else:
        #     return 28
        return 29 if is_leap_year(year) else 28
    if month in (4,6,9,11):
        return 30
    return 31
print(get_day_by_month(10,2020))

可变/不可变类型在传参时的区别

1.不可变类型参数有:
数值型(整数,浮点数,复数)
布尔值bool
None 空值
字符串str
元组tuple
固定集合frozenset
2.可变类型参数有:
列表 list
字典 dict
集合 set
3.传参说明:
不可变类型的数据传参时,函数内部不会改变原数据的值。
可变类型的数据传参时,函数内部可以改变原数据。

下面展示一些 练习

# 定义列表升序排列的函数
list01= [43,4,5,6,7]
def sort(list_target):
    # 满足以下两个条件,就无需通过返回值传递结果。
    # 1.传入的是可变对象
    # 2.函数体修改的是传入的对象
    for r in range(len(list_target) - 1):
        for c in range(r + 1, len(list_target)):
            if list_target[r] > list_target[c]:
                list_target[r], list_target[c] = list_target[c], list_target[r]
sort(list01)
print(list01)

作用域

1.作用域:变量起作用的范围。
2.Local局部作用域:函数内部。
3.Enclosing 外部嵌套作用域 :函数嵌套。
4.Global全局作用域:模块(.py文件)内部。
5.Builtin内置模块作用域:builtins.py文件。
下面展示一些 内联代码片

# 全局变量
g01 = "ok"

# print(l01)
def fun01():
    # 局部变量:在函数内部定义的变量
    l01 = 100
# print(l01)
    print(l01)
    #  在函数内部可以读取全局变量
    # print(g01)

    # 创建了一个局部变量g01,而不是修改全局变量
    # g01 = "no"

    # 定义全局变量g01
    global g01
    # 此时修改的是全局变量
    g01 = "no"
    print(g01)
    # 定义全局变量g02
    global g02
    g02 = 250

局部变量
1.定义在函数内部的变量(形参也是局部变量)
2.只能在函数内部使用
3.调用函数时才被创建,函数结束后自动销毁
全局变量
1.定义在函数外部,模块内部的变量。
2.在整个模块(py文件)范围内访问(但函数内不能将其直接赋值)。
global 语句
1.作用:
在函数内部修改全局变量。
在函数内部定义全局变量(全局声明)。
2.语法:
global 变量1, 变量2, …
3.说明
在函数内直接为全局变量赋值,视为创建新的局部变量。
不能先声明局部的变量,再用global声明为全局变量。

函数参数

实参传递方式argument
1.位置传参
定义:实参与形参的位置依次对应。
fun01(1, 2, 3, 4)
2.序列传参
定义:实参用将序列拆解后与形参的位置依次对应。
序列实参:星号将序列拆分后按位置与形参进行对应
如果参数很多,可以存储在序列(字符串/列表/元组)中,
再通过
拆分,直接传入函数.
3.关键字传参
定义:实参根据形参的名字进行对应。
fun01(b=1, d=2, c=3, a=4)
4.字典关键字传参
1.定义:实参用将字典拆解后与形参的名字进行对应。
2.作用:配合形参的缺省参数,可以使调用者随意传参。
字典实参:双星号将字典拆分后按名称与形参进行对应
如果参数很多,可以存储在字典中,
再通过分,传入函数.
dict01 = {“a”: 1, “c”: 3, “d”: 4, “b”: 2}
fun01(**dict01)
list01 = [“a”,“b”,“c”,“d”]
fun01(*list01)

形参定义方式parameter

缺省参数
1.语法:
def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):
函数体
1.缺省(默认)形参:如果实参不提供,可以使用默认值.
2.说明:
缺省参数必须自右至左依次存在,如果一个参数有缺省参数,则其右侧的所有参数都必须有缺省参数。
缺省参数可以有0个或多个,甚至全部都有缺省参数。

关键字实参 + 缺省形参:调用者可以随意传递参数.

1.位置形参
语法:
def 函数名(形参名1, 形参名2, …):
函数体
2.星号元组形参
1.语法:
def 函数名(元组形参名):
函数体
2.作用:
收集多余的位置传参。
3.说明:
一般命名为’args’
形参列表中最多只能有一个
3
*.星号元组形参**: * 将所有实参合并为一个元组
3.命名关键字形参
1.语法:
def 函数名(*, 命名关键字形参1, 命名关键字形参2, …):
函数体
def 函数名(*args, 命名关键字形参1, 命名关键字形参2, …):
函数体
2.作用:
强制实参使用关键字传参

4.命名关键字形参:在星号元组形参以后的位置形参
目的:要求实参必须使用关键字实参.
作用:让实参个数无限
双星号字典形参
1.语法:
def 函数名(**字典形参名):
函数体
2.作用:
收集多余的关键字传参
3.说明:
一般命名为’kwargs’
形参列表中最多只能有一个
4. 双星号字典形参:**目的是将实参合并为字典.
#实参可以传递数量无限的关键字实参.