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。

"""
    练习:猜数字游戏
    游戏运行产生一个１－－１００之间的随机数。
    让玩家重复猜测，直到猜对为止。
    提示:大了
    　　　小了
    　　　　猜对了，总共猜了多少次
"""
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。

# 练习:循环根据成绩判断等级,如果录入空字符串则退出程序.
# 如果成绩录入错误次数达到３．则退出成绩并提示"成绩错误过多"
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。

# 练习４:在列表中[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中大于１０元素,增加１以后存入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)
下面展示一些 元组练习。

"""
    练习:在控制台中录入日期(月日)，计算这是这一年的第几天.
    例如：３月５日
         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.字典的插入,删除,修改的速度快于列表。
列表的存储是有序的,字典的存储是无序的。
下面展示一些 扩展练习。

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

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
# 解决方案１:键值互换
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. 双星号字典形参：**目的是将实参合并为字典.
#实参可以传递数量无限的关键字实参.