python基础笔记一

计算机基础结构

硬件

1944年,美籍匈牙利数学家冯·诺依曼提出计算机基本结构。
五大组成部分:运算器、控制器、存储器、输入设备、输出设备。
-- 运算器:按照程序中的指令,对数据进行加工处理。

-- 控制器:根据程序需求,指挥计算机的各个部件协调工作。
通常将运算器和控制器集成在中央处理器(CPU)中。

-- 存储器:保存各类程序的数据信息。
		内存RAM -- 容量小,速度快,临时存储数据 
		硬盘HDD -- 容量大,速度慢,永久存储数据

输入设备:外界向计算机传送信息的装置。
		例如:鼠标、键盘、扫描仪…
输出设备:计算机向外界传送信息的装置。	
		例如:显示器、音响、打印机…

软件

操作系统:

	-- 管理和控制计算机软件与硬件资源的程序。
	
	-- 隔离不同硬件的差异~~,使软件开发简单化。
	
	-- Windows,Linux,Unix。

应用软件:为了某种特定的用途而被开发的软件。

软件:程序 + 文档。

-- 程序是一组计算机能识别和执行的指令集合。
	
-- 文档是为了便于了解程序所需的说明性资料。

Python 简介

Python 定义

是一个免费、开源、跨平台、动态、面向对象的编程语言。

# Python程序的执行方式

交互式

在命令行输入指令,回车即可得到结果。

1.打开终端

2.进入交互式:python3

3.编写代码:print(“hello world”) 

4.离开交互式:exit()

文件式

将指令编写到.py文件,可以重复运行程序。

1.编写文件。

2.打开终端

3.进入程序所在目录:cd 目录

4.执行程序: python3 文件名

Linux常用命令

1.pwd:查看当前工作目录的路径 

2.ls:查看指定目录的内容或文件信息 

3.cd:改变工作目录(进入到某个目录)

练习:

1.在指定目录创建python文件.

    --目录:/home/tarena/month01

    --文件名:exercise01.py

2. 在文件中写入:print(“你好,世界!”)

3. 运行python程序

执行过程

计算机只能识别机器码(1010),不能识别源代码(python)。

1.由源代码转变成机器码的过程分成两类:编译和解释。

2.编译:在程序运行之前,通过编译器将源代码变成机器码,例如:C语言。

    -- 优点:运行速度快
    -- 缺点:开发效率低,不能跨平台。

3.解释:在程序运行之时,通过解释器对程序逐行翻译,然后执行。例如Javascript

    -- 优点:开发效率高,可以跨平台;
    -- 缺点:运行速度慢。
    
4.python是解释型语言,但为了提高运行速度,使用了一种编译的方法。编译之后得到pyc文件,存储了字节码(特定于Python的表现形式,不是机器码)。

        源代码 -- 编译 --> 字节码 -- 解释 --> 机器码
            |————1次———|

解释器类型

1.CPython(C语言开发)

2.Jython (java开发)

3.IronPython (.net开发)

数据基本运算

基础知识

pycharm常用快捷键

1.移动到本行开头:home键

2.移动到本行末尾:end键盘

3.注释代码:ctrl + /

4.复制行:ctrl +d

5.选择列:shift + alt + 鼠标左键

6.移动行:shift + alt + 上下箭头

7.智能提示:ctrl + space

8.代码格式化:ctrl+alt+l

注释

给人看的,通常是对代码的描述信息。

1.单行注释:以#号开头。
# print("x")
2.多行注释:三引号开头,三引号结尾。
"""
汇率转换器  exercise01.py
"""

函数

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

# 1. 字面意思:打印(输出/显示)
# 2. 作用:将括号中的内容显示在终端中
# 3. 适用性:显示结果
# print("结果")

# 1. 字面意思:输入
# 2. 作用:将终端中录入的信息输入到程序中
# 3. 适用性:获取数据
# result = input("提示信息")
name = input("请输入姓名:")
print("你好:" + name)
"""
    练习1:收银台
        获取商品价格
        获取购买数量
        获取支付金额
        显示:应该找回?元.
        算法:支付金额 - 价格 × 数量
"""

commodity_price = input("请输入商品价格:")
buy_count = input("请输入购买数量:")
money = input("请输入金额:")

result = float(money) - float(commodity_price) * int(buy_count)

print("应该找回" + str(result) + "元.")

变量

1.定义:关联一个对象的标识符。
2.命名:必须是字母或下划线开头,后跟字母、数字、下划线。
             不能使用关键字(蓝色),否则发生语法错误:SyntaxError: invalid syntax。
3.建议命名:字母小写,多个单词以下划线隔开。
          class_name
4.赋值:创建一个变量或改变一个变量关联的数据。
5.语法:变量名 = 数据
          变量名1 = 变量名2 = 数据
          变量名1, 变量名2, = 数据1, 数据2
"""
    变量
        程序运行在哪里?  -->  内存
        程序在处理什么?  -->  数据
        核心价值:在内存中操作数据
        语法:
            名称 = 数据
            名称1,名称2 = 数据1, 数据2
            名称1 = 名称2 = 数据1
    练习:exercise01
"""
#  赋值号=  : 将右边给到左边
score = 100

score1, score2 = 95, 96

name1 = name2 = "悟空"  
"""
    画出下列代码内存图:
"""
data01 = "苏大强"
data02 = data01
data01 = "大强"
print(data02)# ? 

del 语句

1.语法: 
del 变量名1, 变量名2
2.作用:
用于删除变量,同时解除与对象的关联.如果可能则释放对象。
3.自动化内存管理的引用计数:
每个对象记录被变量绑定(引用)的数量,当为0时被销毁。
"""
    del
    引用计数
    练习:exercise02
"""
data01 = 500
data02 = data01
data03 = data02
"""
    画出下列代码内存图
"""

name02 = name01 = "八戒"
name03 = name02
del name01
name03 = name02 = "悟空"

核心数据类型

1.在python中变量没有类型,但关联的对象有类型。
2.通过type函数可查看。

空值对象 None

1.表示不存在的特殊对象。
2.作用:占位和解除与对象的关联。
# 1. 空None类型
# -- 占位
name = None
# -- 解除与对象的关联
score = 100
score = None

整形int

1.表示整数,包含正数、负数、0。
如: -5, 100, 0
2.字面值:
十进制:5 
二进制:0b开头,后跟1或者1
八进制:0o开头,后跟0~7
十六进制:0x开头,后跟0~9,A~F,a~f
# 2. 整形(整数)int类型
# -- 十进制:逢十进一 0 1 2 3 4 ..9  进位 10
data01 = 10
# -- 二进制:逢二进一 0 1 进位 10  11   100   101   110
data02 = 0b10
# -- 八进制:逢八进一 0 1 2 ...7 进位 10  11
data03 = 0o10
# -- 十六进制:逢十六进一 0 1 2 ...9  a(10)..f(15) 进位 10   11 ..
data04 = 0x10

浮点型float

1.表示小数,包含正数、负数,0.0)。
2.字面值:
小数:1.0   2.5
科学计数法:e/E (正负号) 指数 
       		1.23e-2 (等同于0.0123)
       	1.23456e5(等同于123456.0)
# 3. 浮点型(小数)float类型
number01 =1.5
print(number01)
number02 =15e-1
number03 = 0.00000000001# 1e-11
print(number03)

字符串str

是用来记录文本信息(文字信息)。
字面值:双引号
"""
    字符串
    练习:exercise05
"""

# 1. 不可变
name = "悟空"
name = "孙悟空"
print(name)  # 创建新字符串对象(孙悟空),替换变量存储的地址。
# 假设可以在原有基础上进行扩充,很可能破坏其他对象内存空间.

# 2. 编码相关函数
# 字 -->  数
print(ord("天"))

# 数 --> 字
print(chr(22825))
# 4. 字符串str类型
message = "我爱编程"
message = "1.5"
"""
    古代的秤,一斤十六量.
    获取两,显示几斤零几两.
"""
weight_liang = int(input("请输入两:"))
jin = weight_liang // 16
liang = weight_liang % 16
print(str(jin) + "斤零" + str(liang) + "两")

布尔bool

用来表示真和假的类型
True 表示真(条件满足或成立),本质是1
False 表示假(条件不满足或不成立),本质是0
# 1. 布尔 bool 类型
# 命题:带有判断性质的陈述句
#      我是一个帅哥
#      真/对/成立    True
#      假/错/不成立  False

# 类型转换: bool(数据)  有值true  没值false

print(bool(0))  # False
print(bool(0.0))  # False
print(bool(""))  # False
print(bool(None))  # False

数据类型转换

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
"""
    类型转换
        语法逻辑:
            结果 = 类型名(待转类型)
"""

# input函数的结果是str类型

# str ---> int / float
# 适用性:需要对象字符串进行数学运算
# 注意:待转数据必须"像"转换的类型.
number = float("200.5")
print(number)

# int / float ---> str
# 适用性:需要按照某种格式显示计算后的数值
print(str(10.5))

运算符

算术运算符

+	加法
-	减法
*	乘法
/	除法:结果为浮点数
//	地板除:除的结果去掉小数部分
%	求余
**	幂运算
优先级从高到低: ()
          		 **
                 *  / % //
                 +  -
"""
    公式:
        距离 =初速度 * 时间的一半 + 加速度 × 时间的平方
    已知:
        距离,时间,初速度
    计算:
        加速度

    加速度 = (距离 - 初速度 * 时间 / 2) / 时间**2
"""
s = float(input("请输入距离:"))
t = float(input("请输入时间:"))
v0 = float(input("请输入初速度:"))
a = (s - v0 * t / 2) / t ** 2
print(a)

"""
    练习:时间换算
        获取分钟数
        获取小时数
        获取天数
        显示:?天?小时?分钟总共是?秒.
"""
minute = input("请输入分钟数:")
hour = input("请输入小时数:")
day = input("请输入天数:")
result = int(minute) * 60 + int(hour) * 60 * 60 + int(day) * 24 * 60 * 60
print(day + "天" + hour + "小时" + minute + "分钟总共是" + str(result) + "秒.")
# 1. + - *  / //  %   幂运算**
number01 = 5
number02 = 2
result = number01 + number02  # 7
print(result)

print(number01 ** 2)  # 5 的2 次方: 5 * 5

number01 = "5"
number02 = "2"
result = number01 + number02  # 不是数学运算,而是文字拼接52
print(result)

# 需求1:整数的个位数是多少?  --> 余数
number = 56
print(number % 10)  # 6

# 需求2:70秒是几分钟零几秒? --> 地板除(整数除)
second = 70
print(second // 60)  # 分钟
print(second % 60)  # 秒

增强运算符

y += x		等同于 y = y + x
y -= x		等同于 y = y - x
y *= x		等同于 y = y * x
y /= x		等同于 y = y / x
y //= x		等同于 y = y // x
y %= x		等同于 y = y % x
y **= x		等同于 y = y ** x
"""
    获取一个4位整数           1234
    输出每位相加和            1+2+3+4
"""
# # 方法1
# number = int(input("请输入整数:"))
# # 个位
# unit01 = number % 10
# # 十位 1234 --> 123  --> 3
# unit02 = number // 10 % 10
# # 百位 1234 --> 12  --> 2
# unit03 = number // 100 % 10
# # 千位  1234 --> 1
# unit04 = number // 1000
# print(unit01 + unit02 + unit03 + unit04)

# 方法2
number = int(input("请输入整数:"))
# 个位
result = number % 10
# 十位
result += number // 10 % 10
# 百位
result += number // 100 % 10
# 千位  1234 --> 1
result += number // 1000
print(result)
# 2. 增强运算符 += -=  *=   /=   //=  %=  **=
# data01 = 6
# 运算后的结果,不影响变量自身
# print(data01 + 1)# 7
# print(data01)# ? 6

data01 = 6
# 运算后的结果,又赋值给了变量自身.
data01 += 1 # data01 = data01 + 1
print(data01)# 7

比较运算符

 <		小于
 <=		小于等于
 >		大于
 >=		大于等于
 ==		等于
 !=		不等于
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100
# 2. >  <   >=   <=  等于==  不等于!=
#  比较数值大小,结果是bool类型
data01 = 50
data02 = "50"
print(data01 == data02)  # false
print(50 != "50")  # false

逻辑运算符

与and

表示并且的关系,一假俱假。         
示例:
    True and True	# True
    True and False	# False
    False and True	# False
False and False	# False
# 3. 与and   或    非
# 判断多个命题关系

# 与and 现象:一假俱假  并且关系(必须满足所有条件)
print(True and True)  # True
print(False and True)  # False
print(True and False)  # False
print(False and False)  # False

或or

表示或者的关系,一真俱真     
  示例:
True or True		# True
True or False		# True
False or True		# True
False or False		# False 
# 或or 现象:一真俱真  或者关系(满足一个就行)
print(True or True)  # True
print(False or True)  # True
print(True or False)  # True
print(False or False)  # False

非 not

表示取反
例如:
not True   # 返回False
not False  # 返回True
# 非  取反
print(not True)  # False

短路运算

一但结果确定,后面的语句将不再执行。
"""
    短路逻辑
        一但结果确定,后面的语句将不再执行。
        价值:尽量将耗时的判断放在后面
"""

# False  and ?
result = 1 > 2 and input("请输入") == "a"


# True  or ?
result = 1 < 2 or input("请输入") == "a"
# 终端中是否有"请输入"
"""
    获取一个年份
    如果是闰年输入True,否则输出false
    条件:
        1. 年份能被4整除但是不能被100整除
        2. 年份能被400整除
"""
year = int(input("请输入年份:"))
result = year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(result)

身份运算符

语法:
		x is y
		x is not y
作用:
is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
   		is not 的作用与is相反
"""
    身份运算符
"""
list01 = [100]
list02 = [100]

# 两个变量指向的对象是否同一个
print(list01 is list02)# False

list03 = list01
print(list03 is list01)# True

# 原理:判断变量存储的地址是否相同
print(id(list01))# 140235347048584
print(id(list02))# 140235357765192
print(id(list03))# 140235347048584

优先级

	高到低:
    算数运算符
    比较运算符
    快捷运算符
    身份运算符
    逻辑运算符

语句

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

# 1个逻辑行对应1个物理行(建议)
a = 10
b = 20
c = a + b

# 3个逻辑行对应1个物理行(不建议)
a = 10;b = 20;c = a + b

# 1个逻辑行对应多个物理行
# 换行符 \
d = 1 + 2 + \
    3 + 4 + 5 + 6 + \
    7 + 8 + 9
# 换行符 括号是天然的换行符
e = (1 + 2
     + 3 + 4 +
     5 + 6 + 7 +
     8 + 9)

pass 语句

通常用来填充语法空白。

选择语句

If elif else 语句

1.作用:
    	让程序根据条件选择性的执行语句。
2.语法:
    if 条件1:
        语句块1
    elif 条件2:
        语句块2
    else:
        语句块3
3.说明:
    elif 子句可以有0个或多个。
    else 子句可以有0个或1个,且只能放在if语句的最后。
"""
    选择语句
       缩进:4个空格
        if 条件:
            满足条件执行的代码
        else:
            不满足条件执行的代码


        if 条件1:
            满足条件1执行的代码
        elif 条件2:
            不满足条件1,但满足条件2执行的代码
        else:
            以上条件都不满足执行
    # 调试:让程序中断,逐语句执行。
    # 目标:审查程序执行过程
    #      观察变量取值
    # 步骤:
    #    1. 加断点(在可能出错的行)
    #    2. 开始调试
    #    3. 逐语句执行F8/F7
    #    4. 停止Ctrl + F2
    练习:exercise01~05
"""
sex = input("请输入性别:")
if sex == "男":
    print("您好,先生!")
elif sex == "女":
    print("您好,女士!")
else:
    print("性别未知")
"""
    修改day02/exercise04练习
    显示结果:
        应找回...
        钱不够
"""

commodity_price = input("请输入商品价格:")
buy_count = input("请输入购买数量:")
money = input("请输入金额:")
result = float(money) - float(commodity_price) * int(buy_count)
if result >= 0:
    print("应该找回" + str(result) + "元.")
else:
    print("钱不够")
"""
    获取季度(春天  夏天  秋天  冬天)
    显示相应的月份:
        春天:1月2月3月
        夏天:4月5月6月
        秋天:7月8月9月
        冬天:10月11月12月
"""
season = input("请输入季度:")
# if season == "春天":
#     print("1月2月3月")
# if season == "夏天":
#     print("4月5月6月")
# if season == "秋天":
#     print("7月8月9月")
# if season == "冬天":
#     print("10月11月12月")

if season == "春天":
    print("1月2月3月")
elif season == "夏天":
    print("4月5月6月")
elif season == "秋天":
    print("7月8月9月")
elif season == "冬天":
    print("10月11月12月")
"""
    录入4个同学体重,
    打印最重的体重。
    算法:
        假设第一个是最大值
        如果第二个大于假设的,则替换假设的.
        如果第三个大于假设的,则替换假设的.
        如果第四个大于假设的,则替换假设的.
        最后输出假设的(最大的)
"""
weight01 = float(input("请输入第一个同学体重:"))
weight02 = float(input("请输入第一个同学体重:"))
weight03 = float(input("请输入第一个同学体重:"))
weight04 = float(input("请输入第一个同学体重:"))
max_value = weight01
if max_value < weight02:
    max_value = weight02
if max_value < weight03:
    max_value = weight03
if max_value < weight04:
    max_value = weight04
print(max_value)
"""
    获取成绩
    判断等级(优秀 良好 及格 不及格  不在范围内0-100)
"""

score = float(input("请输入成绩:"))
# if 90 <= score <= 100:
#     print("优秀")
# elif 80 <= score < 90:
#     print("良好")
# elif 60 <= score < 80:
#     print("及格")
# elif 0 <= score < 60:
#     print("不及格")
# else:
#     print("不在范围内0-100")

if score > 100 or score < 0:
    print("不在范围内0-100")
elif 90 <= score:
    print("优秀")
elif 80 <= score:
    print("良好")
elif 60 <= score:
    print("及格")
else:
    print("不及格")

"""
    获取一个年份,一个月份
    打印相应天数
    1 3 5 7 8 10 12 -->  31天
    2 --> 28(平年)    29(闰年)
    4 6 9 11 --> 30天
"""
year = int(input("请输入年份:"))
month = int(input("请输入月份:"))

if month < 1 or month > 12:
    print("月份有误")
elif month == 2:
    if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
        print("29天")
    else:
        print("28天")
elif month == 4 or month == 6 or month == 9 or month == 11:
    print("30天")
else:  # 1 3 5 7 8 10 12
    print("31天")

if 语句的真值表达式

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

条件表达式

  语法:变量 = 结果1 if 条件 else 结果2
  作用:根据条件(True/False) 来决定返回结果1还是结果2。
"""
    真值表达式
    条件表达式
    练习:exercise06
"""

# 真值表达式
message = input("请输入")
# if message != "":
if message:  # 有值
    print("输入了内容")
else:
    print("没有输入内容")

# 条件表达式
# if input("请输入性别:") == "男":
#     sex_code = 1
# else:
#     sex_code = 0
sex_code = 1 if input("请输入性别:") == "男" else 0

# 练习1:
# 获取一个整数,如果是奇数给变量state赋值为"奇数",否则赋值"偶数"

# if int(input("请输入整数:")) % 2 == 1:
#     state = "奇数"
# else:
#     state = "偶数"

# if int(input("请输入整数:")) % 2:
#     state = "奇数"
# else:
#     state = "偶数"

state = "奇数" if int(input("请输入整数:")) % 2 else "偶数"
print(state)

# 练习2:
# 获取一个年份,如果是闰年给变量day赋值为29,否则赋值28
year = int(input("请输入年份:"))
# 建议
day = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
# day = 29 if not year % 4 and year % 100 or not year % 400 else 28

循环语句

while语句

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

#  死循环
while True:
    str_usd = input("请输入美元:")
    result = float(str_usd) * 6.9845
    print(str_usd + "美元=" + str(result) + "人民币")

    if input("如果输入y则继续:") != "y":
        break  # 退出循环
"""
    改造exercise02.py(季度 --> 月份)
    如果输入e键退出,否则循环执行。
    调试:体会循环
"""

while True:
    season = input("请输入季度:")
    if season == "春天":
        print("1月2月3月")
    elif season == "夏天":
        print("4月5月6月")
    elif season == "秋天":
        print("7月8月9月")
    elif season == "冬天":
        print("10月11月12月")
    if input("请输入e键退出:") == "e":
        break

"""
    循环计数
    1. 在循环以前定义计数器
    2. 在循环以内更新计数器
    练习:exercise08
"""

# 需求:执行5次
count = 0
while count < 5:
    # print("跑圈")
    print(count)  # 0 1 2 3 4
    count += 1
# 练习1:在终端中显示0 1 2
# count = 0
# while count <= 2:
#     print(count)
#     count += 1

# 练习2:在终端中显示6 7 8 9  10
# count = 6
# while count <= 10:
#     print(count)
#     count += 1

# 练习3:在终端中显示2 4 6 8
# count = 2
# while count <= 8:
#     print(count)
#     count += 2
# 练习4:在终端中显示9 8 7 6 5 4 3
# count = 9
# while count >= 3:
#     print(count)
#     count -= 1
# 练习5:在终端中显示-1 -2 -3 -4 -5 -6
count = -1
while count >= -6:
    print(count)
    count -= 1
"""
    获取一个开始值,再获取一个结束值.
    打印中间值
    5      10   -->   6 7 8 9
    10     5   -->    9 8 7 6
"""
# 精神:顽强的拼搏力和无所畏惧的勇气.

begin = int(input("请输入开始值:"))  # 5
end = int(input("请输入结束值:"))  # 10

# 行为相同  数据不同
# while begin < end - 1:
#     begin += 1
#     print(begin)
#
# while begin > end + 1:
#     begin -= 1
#     print(begin)

dir = 1 if begin < end else -1
while begin != end - dir:
    begin += dir
    print(begin)
"""
    一张纸的厚度是0.01毫米
    请计算,对折多少次超过珠穆朗玛峰(8844.43米).
"""

# 数据:厚度、次数
# thickness = 0.01 / 1000
# 算法:*=2   += 1

thickness = 1e-5
count = 0
while thickness <= 8844.43:
    thickness *= 2
    count += 1
    print("第" + str(count) + "次对折后的厚度是" + str(thickness))
print(count)
"""
    猜数字游戏:
        程序产生1--100之间的随机数.
        在终端中重复猜测,直到猜对为止
        提示:请输入  大了  小了   终于猜对了
"""
# 准备一个随机数工具
import random

# 生成一个随机数
random_number = random.randint(1, 100)

while True:
    input_number = int(input("请输入:"))
    if input_number > random_number:
        print("大了")
    elif input_number < random_number:
        print("小了")
    else:
        print("终于猜对了")
        break
"""
    增加需求:最多只能猜3次,如果超过次数则提示"游戏失败"
"""

# 准备一个随机数工具
import random

# 生成一个随机数
random_number = random.randint(1, 100)
print(random_number)
count = 0
while count < 3:
    count += 1
    input_number = int(input("请输入:"))
    if input_number > random_number:
        print("大了")
    elif input_number < random_number:
        print("小了")
    else:
        print("终于猜对了")
        break
else:# 否则:当循环条件不满足时执行(从循环体中通过break退出不执行)
    print("游戏失败")

for 语句

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

message = "我是齐天大圣孙悟空"

for item in message:
    print(item)# "1"   -->  1
# 练习:
# 获取一个任意整数           123456
# 输出每位相加和            1+2+3+4+...
str_number = input("请输入任意整数:")

# 1. 循环以前定义变量(存储累加和)
sum_value = 0

for item in str_number:
    # 2. 循环以内进行累加
    sum_value += int(item)

# 3. 循环以外获取结果
print(sum_value)

range 函数

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

# 整数生成器:产生一个范围内的整数
# 开始值  结束值(不包含)  变化量
for item in range(0, 6, 1):
    print(item)  # 0 1 2 3 4 5

# 结束值(开始值默认为0,变化量默认为1)
for item in range(6):
    print(item)

# 开始值,结束值
for item in range(3, 6):
    print(item)
# 练习1:在终端中显示0 1 2
for item in range(3):
    print(item)
# 练习2:在终端中显示6 7 8 9  10
for item in range(6,11):
    print(item)
# 练习3:在终端中显示2 4 6 8
for item in range(2,9,2):
    print(item)
# 练习4:在终端中显示9 8 7 6 5 4 3
for item in range(9,2,-1):
    print(item)
# 练习5:在终端中显示-1 -2 -3 -4 -5 -6
for item in range(-1,-7,-1):
    print(item)

跳转语句

break 语句

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

continue 语句

跳过本次,继续下次循环。
"""
    continue
    练习:exercise04

    语句小结:
        循环语句:
            while :根据条件重复执行(不知道次数)
                例如:对折到超过珠穆朗玛则停止
            for : 根据次数执行(循环计数)
                例如:3道考试题/对折20次
        跳转语句:
            break:跳出(循环停止)
            continue:跳过(循环继续)
            备注:如果循环嵌套,跳转语句只对一层起作用.

        range 属于可迭代对象,所以获取数据使用for.
"""
# 累加:1--100之间能被3整除的整数
# sum_value = 0
# for number in range(1, 101):
#     满足条件则累加
#     if number % 3 == 0:
#         sum_value += number
# print(sum_value)

sum_value = 0
for number in range(1, 101):
    #     不满足条件则跳过
    if number % 3 != 0:
        continue  # 跳过(当前元素,继续循环)
    sum_value += number
print(sum_value)
"""
    累加10 -- 80 之间个位不是3/5/9的整数
    调试:体会continue的过程
"""
sum_value = 0
for number in range(10, 81):
    unit01 = number % 10
    # 是他们就跳过
    if unit01 == 3 or unit01 == 5 or unit01 == 9:
        continue
    sum_value += number
print(sum_value)

容器类型

通用操作

数学运算符

1.+:用于拼接两个容器
2.+=:用原容器与右侧容器拼接,并重新绑定变量
3.*:重复生成容器元素
4.*=:用原容器生成重复元素, 并重新绑定变量
5.< <= > >= == !=:依次比较两个容器中元素,一但不同则返回比较结果。
# 1. 算数运算符
# -- +容器元素拼接
name01 = "悟空"
name01 += "八戒"
# -- *容器元素重复多次
name02 = "唐僧"
name02 *= 2
print(name02)
# -- == !=
# 依次比较两个容器中元素,一但不同则返回比较结果。
print("悟空" > "八戒")

成员运算符

1.语法:
	 数据 in 序列
数据 not in 序列
2.作用:
	 	 如果在指定的序列中找到值,返回bool类型。
# 2. 成员运算 in   not in
print("我爱" in "我爱你")  # true
print("爱我" in "我爱你")  # flase

索引index

1.作用:定位单个容器元素
2.语法:容器[整数]
3.说明:
    正向索引从0开始,第二个索引为1,最后一个为len(s)-1。
    反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。
# 3. 索引:定位单个元素
print(message[1])
print(message[-2])
# 索引越界
# print(message[7])# 报错 IndexError
# print(message[-8])# 报错 IndexError

切片slice

1.作用:
    定位多个容器元素。
2.语法:
    容器[(开始索引):(结束索引)(:(步长))]
3.说明:
    小括号()括起的部分代表可省略
    结束索引不包含该位置元素
    步长是切片每次获取完当前元素后移动的偏移量
# 4. 切片:定位多个元素
# range(  ,  ,  )

# [开始索引:结束索引:间隔]    不包含结束索引
print(message[0:4:1])  # 我是齐天
# [:结束索引:]
print(message[:4:])  # 我是齐天
# [:]
print(message[:])  # 我是齐天大圣.
# message[::-1]
print(message[::-1])  # .圣大天齐是我
# [开始索引::]
print(message[3::])  # 天大圣.
# [::间隔]
print(message[::2])  # 我齐大.
# 切片不会越界
print(message[:100])  # 我是齐天大圣.
print(message[3:3])  # 获取空
print(message[1:-2])  # 是齐天大
print(message[1:5:-1])  # 获取空
# 练习:
# -- 打印第一个字符
# -- 打印最后一个字符
# -- 打印中间的字符 len(message)
# -- 打印前3个字符
# -- 打印后4个字符(正向)
# -- 打印:是教主无
# -- 倒序打印所有字符
# -- 尝试...
message = "我是明教教主张无忌"
print(message[0])
print(message[-1])
print(message[len(message) // 2])
print(message[:3])
print(message[-4:])
print(message[1::2])
print(message[::-1])

内建函数

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

字符串 str

定义

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

编码

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. 双引号
name01 = "悟空"
#    单引号
name02 = '悟空'

三引号作用

1.换行会自动转换为换行符\n
2.三引号内可以包含单引号和双引号
3.作为文档字符串
#    三引号(可见即所得)
name03 = '''悟空'''
name04 = """悟空"""

message = '我叫"齐天大圣".'
message = "我叫'齐天大圣'."
message = """我叫'齐"天大"圣'."""

转义字符

1.改变字符的原始含义。
\’  \”  \”””  \n  \\  \t  \0 空字符  
2.原始字符串:取消转义。
			a = r”C:\newfile\test.py”
# 2. 转义字符:改变字符的原始含义。
# \"  \'   \\
message = "我叫\"齐天大圣\"."
url = "C:\\arogram Files\\bntel\cedia SDK"
# 原始字符串:没有转义字符
url = r"C:\arogram Files\bntel\cedia SDK"
print(url)
# \t 水平制表格
print("我爱\t编程.")
# \n 换行
print("我爱\n编程.")

字符串格式化

1.定义:
生成一定格式的字符串。
2.语法:
字符串%(变量)
"我的名字是%s,年龄是%s" % (name, age)
3.类型码:
%s 字符串     %d整数     %f 浮点数
# 3. 字符串格式化
name = "qtx"
age = 18
score = 95.12345
print("我的名字是%s,年龄是%d,成绩是%.3f" % (name, age, score))
# 根据格式显示字符串
# ?天?小时?分钟
# print(day + "天" + hour + "小时" + minute + "分钟")
day = 1
hor = 2
minute = 3
print("%d天%d小时%d分钟" % (day, hor, minute))

# ?斤零?两
# print(str(jin) + "斤零" + str(liang) + "两")
jin = 3
liang = 2
message = "%d斤零%d两" % (jin, liang)
print(message)

# ?+?=?
# print(str(number01) + "+" + str(number02) + "=?")
number01 = 10
number02 = 5
print("%d+%d=%d" % (number01, number02, number01 + number02))

列表 list

定义

由一系列变量组成的可变序列容器。
基础操作
1.创建列表: 
列表名 = []   
列表名 = list(可迭代对象)
# 1. 创建
# -- 直接存储数据
list01 = []
list01 = ["悟空", "八戒"]
# -- 将其他可迭代对象存入列表
list02 = list("我是齐天大圣")
2.添加元素:
列表名.append(元素) 
列表.insert(索引,元素)
# 2. 增加
# -- 追加(末尾)
list01.append("唐僧")
# -- 插入(在指定)
list01.insert(1, "沙僧")
3.定位元素:
列表名[索引] = 元素
变量 = 列表名[索引]
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表 
列表名[切片] = 容器 # 右侧必须是可迭代对象,左侧切片没有创建新列表。遍历列表:
	正向:
	for 变量名 in 列表名:
		变量名就是元素
		反向:
	for 索引名 in range(len(列表名)-1,-1,-1):
		列表名[索引名]就是元素

4.删除元素:
列表名.remove(元素) 
  	del 列表名[索引或切片]
深拷贝和浅拷贝
浅拷贝:复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝:复制整个依懒的变量。
"""
    深拷贝

    优点:
        对其中之一的修改,
        绝对不影响另外一个.
    缺点:
        比较占用内存
"""
# 准备深拷贝的工具
import copy

list01 = [
    [1,2,3],
    [4,5,6]
]
# list02 =list01[:]
# 深拷贝列表
list02 = copy.deepcopy(list01)
list01[0] = "一"
list01[1][0] = "二"
print(list02)#

# 3. 删除
# -- 根据元素
if "八戒2" in list01:
    list01.remove("八戒2")  # 备注:如果没有元素则报错
# -- 根据位置
# del list01[1]
del list01[1:3]
# 4. 修改
print(list02)
# -- 索引
# list02[0] = "你" # 索引
# -- 切片
# 原理:遍历右侧可迭代对象,将每个元素赋值给左边切片定位的元素
list02[2:3] = [1,2,3,4,5]
print(list02)

# 5. 查询
# -- 索引
print(list02[-1])
# -- 切片
# 原理:切片后返回新列表(拷贝)
print(list02[:])
# -- 循环
for item in list02:
    print(item)

# 需求倒序获取所有元素(不建议切片)
# for item in list02[::-1]:
#     print(item)

for index in range(len(list02)-1,-1,-1):
    print(list02[index])

列表VS字符串

1.列表和字符串都是序列,元素之间有先后顺序关系。
2.字符串是不可变的序列,列表是可变的序列。
3.字符串中每个元素只能存储字符,而列表可以存储任意类型。
4.列表和字符串都是可迭代对象。
5.函数:
将多个字符串拼接为一个。
result = "连接符".join(列表)

将一个字符串拆分为多个。
列表 = “a-b-c-d”.split(“分隔符”)
"""
    list --> str
    练习:exercise07
"""
# 根据某些逻辑,拼接字符串.
list01 = ["3", "4", "5", "7"]
# str_result = ""
# for item in list01:
#     # 每次循环,每次拼接,每次创建新对象
#     str_result = str_result + item
# print(str_result)
str_result = "——".join(list01)
print(str_result)
# 在终端中循环录入字符串,如果录入为空,则停止.
# 打印所有录入的内容(一个字符串)

# 核心思想:使用可变对象代替不可变对象,进行频繁操作.
list_result = []
while True:
    content = input("请输入内容:")
    if content == "":
        break
    list_result.append(content)

str_result =  "".join(list_result)
print(str_result)
"""
    str --> list
    练习:exercise08
"""

line = "孙悟空-八戒-唐三藏"
list_person = line.split("-")
print(list_person)

"""
    将英文语句进行反转
    How are you   -->  you are How
"""
message = "How are you"
list_temp = message.split(" ")
str_result = " ".join(list_temp[::-1])
print(str_result)

列表推导式

1.定义:
使用简易方法,将可迭代对象转换为列表。
2.语法:
变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件]
3.说明:
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
"""
    列表推导式
        根据一个可迭代对象,构建另外一个列表。
    练习:exercise09
"""
# 需求1:将list01中每个元素增加10之后,存入list02
list01 = [34, 45, 54, 65, 67, 87]
# list02 = []
# for item in list01:
#     list02.append(item + 10)
list02 = [item + 10 for item in list01]

print(list02)

# 需求2:将list01中所有偶数增加10之后,存入list02
# list02 = []
# for item in list01:
#     if item % 2 == 0:
#         list02.append(item + 10)
list02 = [item + 10 for item in list01 if item % 2 == 0]
# 练习1:使用列表推导式生成1--50之间能被3或者5整除的数字
list01 = [item for item in range(1, 51) if item % 3 == 0 or item % 5 == 0]
print(list01)

# 练习2:使用列表推导式生成5--60之间数字的平方
list02 = [item ** 2 for item in range(5, 61)]
print(list02)

# 练习3:将1970年到2050年之间的闰年存入列表
list03 = []
for year in range(1970, 2051):
    if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
        list03.append(year)
# list03 = [year for year in range(1970,2051) if year % 4 ==0 and year % 100 !=0 or year % 400 == 0 ]
print(list03)

列表推导式嵌套

1.语法:
变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
2.传统写法:
result = []
for r in  ["a", "b", "c"]:
    for c in ["A", "B", "C"]:
        result.append(r + c)
3.推导式写法:
result = [r + c for r in list01 for c in list02]

元组 tuple

定义

1.由一系列变量组成的不可变序列容器。 
2.不可变是指一但创建,不可以再添加/删除/修改元素。    

基础操作

1.创建空元组:
元组名 = ()
元组名 = tuple()
2.创建非空元组:
元组名 = (20,)
    元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象)
3.获取元素:  
变量 = 元组名[索引]
变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表  
4.遍历元组:
	正向:
	for 变量名 in 列表名:
		变量名就是元素
		反向:
	for 索引名 in range(len(列表名)-1,-1,-1):
		元组名[索引名]就是元素
# 1. 创建
tuple01 = ()
tuple01 = (4, 545, 5665, 7, 78)
list01 = [54, 5, 56, 67]
# 列表(预留空间) -->  元组(按需分配)
tuple02 = tuple(list01)
#  元组(按需分配) --> 列表(预留空间)
list02 = list(tuple01)

# 特殊
# -- 如果元组只有一个数据,必须在后面添加逗号
tuple03 = (4,)
# -- 小括号可以省略
tuple04 = 4, 5, 6
# -- 可以直接将容器赋值给多个变量
a, b, c = (8, 9, 10)
print(type(tuple04))

# 2. 查询
# -- 索引
print(tuple01[-1])  # 获取最后一个
print(tuple01[2])  # 获取第三个
# -- 切片
# 原理:创建新容器
print(tuple01[-3:])  # 最后三个
# -- 循环
for item in tuple01:
    print(item)

for i in range(len(tuple01) - 1, -1, -1):
    print(tuple01[i])

作用

1.元组与列表都可以存储一系列变量,由于列表会预留内存空间,所以可以增加元素。
2.元组会按需分配内存,所以如果变量数量固定,建议使用元组,因为占用空间更小。
3.应用:
变量交换的本质就是创建元组:x, y = (y, x )
格式化字符串的本质就是创建元祖:"姓名:%s, 年龄:%d"  % ("tarena", 15)
"""
    请使用容器的思想,改造下列代码:
        统一管理
"""
year = int(input("请输入年份:"))
month = int(input("请输入月份:"))
# if month < 1 or month > 12:
#     print("月份有误")
# elif month == 2:
#     if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
#         print("29天")
#     else:
#         print("28天")
# # elif month == 4 or month == 6 or month == 9 or month == 11:
# elif month in (4, 6, 9, 11):
#     print("30天")
# else:  # 1 3 5 7 8 10 12
#     print("31天")

# 将每月天数,存入元组
day_of_second = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
days_of_month = (31, day_of_second, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
print(days_of_month[2])  # 三月
print(days_of_month[-1])  # 十二月
"""
    获取年、月、日.
    计算这是这一年的第几天.
    算法:前几个月的总天数 + 当月天数
    2019,5,18
    31 28 31 30 + 18
"""
year = int(input("请输入年:"))
month = int(input("请输入月:"))
day = int(input("请输入天:"))

day_of_second = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
days_of_month = (31, day_of_second, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)

# 累加前几个月的总天数
# total_days = 0
# for i in range( month -1 ):# 0 1 2 3
#     total_days += days_of_month[i]
total_days = sum(days_of_month[: month - 1])

#  累加当月天数
total_days += day

print("这是一年的第"+str(total_days)+"天")

字典 dict

定义

1.由一系列键值对组成的可变散列容器。
2.散列:对键进行哈希运算,确定在内存中的存储位置,每条数据存储无先后顺序。
3.键必须惟一且不可变(字符串/数字/元组),值没有限制。

基础操作

1.创建字典:
字典名 = {键1:值1,键2:值2}
字典名 = dict (可迭代对象) 
# 1. 创建
dict01 = {}
dict01 = {101: "悟空", 102: "八戒", 103: "唐僧"}

# 列表(格式) --> 字典
# 格式:[(k,v),(k,v)]
dict02 = dict(["悟空", (102, "猪八戒"), [103, "唐僧"]])
# 字典 --> 列表(只保留key)
list01 = list(dict01)
2.添加/修改元素:
语法:
    字典名[键] = 数据
说明:
    键不存在,创建记录。
    键存在,修改值。
# 2. 添加
# --通过键-值
dict01[104] = "沙僧"

# 3. 修改(如果key存在,则为修改,不存在则为添加)
dict01[101] = "孙悟空"
3.获取元素:
变量 = 字典名[键]  # 没有键则错误
4.遍历字典:
	for 键名 in 字典名:
		字典名[键名]
for 键名,值名 in 字典名.items():
        语句
# -- 获取所有key
for key in dict01:
    print(key)

# --获取所有value
for value in dict01.values():
    print(value)

# --获取所有key - value
# for item in dict01.items():
#     print(item)# (k,v)

for key,value in dict01.items():
    print(key)
    print(value)
5.删除元素:
del 字典名[键]
# 4. 删除
# 如果key不存在则报错
if 108 in dict01:
    del dict01[108]
"""
    在终端中循环录入商品信息(名称,单价)
    如果名称为空,停止录入.
    -- 打印所有商品信息(一行一个)
        格式:xxx的价格是yyy.
    -- 如果录入了游戏机,单独打印其价格.
"""
dict_commoditys = {}
while True:
    name = input("请输入商品名称:")
    if name == "":
        break
    price = float(input("请输入商品单价:"))
    dict_commoditys[name] = price
for k, v in dict_commoditys.items():
    print("%s的价格是%f." % (k, v))
if "游戏机" in dict_commoditys:
    print(dict_commoditys["游戏机"])
"""
    在终端中循环录入学生信息(名称,年龄,性别,成绩...)
    如果名称为空,停止录入.
    -- 打印所有学生信息(一行一个)
        格式:xxx的年龄是xxx,性别是xxx,成绩是xxx.
    -- 如果录入了"唐僧",单独打印其成绩
    核心:数据结构  字典内嵌列表
        {
            "悟空":[26,"男",86],
            "唐僧":[24,"男",90]
        }
"""
dict_persons = {}
while True:
    name = input("请输入学生姓名:")
    if name == "":
        break
    age = int(input("请输入学生年龄:"))
    sex = input("请输入学生性别:")
    score = float(input("请输入学生成绩:"))
    dict_persons[name] = [age, sex, score]

for k_name, v_infos in dict_persons.items():
    print("%s的年龄是%d,性别是%s,成绩是%f." % (k_name, v_infos[0], v_infos[1], v_infos[2]))

if "唐僧" in dict_persons:
    print(dict_persons["唐僧"][2])
"""
    在终端中循环录入学生信息(名称,年龄,性别,成绩...)
    如果名称为空,停止录入.
    -- 打印所有学生信息(一行一个)
        格式:xxx的年龄是xxx,性别是xxx,成绩是xxx.
    -- 打印最后一个学生的信息
           ...
    核心:数据结构  列表内嵌字典
        [
            {"name":"悟空", "age":26,"sex":"男","score":86},
            {"name":"唐僧", "age":24,"sex":"男","score":90},
        ]
    17:02
    总结:
        列表:通过索引/切片获取数据,定位元素灵活.      【灵活】
        字典:通过key查找值,代码可读性相对较高
              (列表不适合存储多类信息,姓名/年龄/性别)
             利用空间,换取时间,定义单个元素最快.      【快速】
"""
list_persons = []
while True:
    name = input("请输入学生姓名:")
    if name == "":
        break
    age = int(input("请输入学生年龄:"))
    sex = input("请输入学生性别:")
    score = float(input("请输入学生成绩:"))
    dict_person = {"name":name, "age":age,"sex":sex,"score":score}
    list_persons.append( dict_person )

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

# 最后一个学生信息
person = list_persons[-1]
print("%s的年龄是%d,性别是%s,成绩是%f." % (person["name"], person["age"], person["sex"], person["score"]))

字典推导式

1.定义:
使用简易方法,将可迭代对象转换为字典。
2.语法:
{键:值 for 变量 in 可迭代对象}
    {键:值 for 变量 in 可迭代对象 if 条件}

字典 VS 列表

1.都是可变容器。
2.获取元素方式不同,列表用索引,字典用键。
3.字典的插入,删除,修改的速度快于列表。
4.列表的存储是有序的,字典的存储是无序的。

集合 set

定义

1.由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
2.相当于只有键没有值的字典(键则是集合的数据)。
集合set
        价值1:去重复
        价值2:数学运算

基础操作

1.创建空集合: 
集合名 = set()  
集合名 = set(可迭代对象)
2.创建具有默认值集合:
集合名 = {1, 2, 3}
集合名 = set(可迭代对象)
# 1. 创建
# set01 ={}  # 创建字典,不是集合
set01 = {"悟空", "八戒", "唐僧"}
list01 = ["悟空", "八戒", "唐僧", "八戒"]
set02 = set(list01)
print(set02)
3.添加元素:
集合名.add(元素)
# 2. 添加
set01.add("沙僧")
4.删除元素:
集合名.discard(元素)
# 3. 删除
set01.remove("悟空")
# 4. 修改(先删除后添加)

print(set01)

运算

1.交集&:返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
 	s3 = s1 & s2  # {2, 3}
# 交集
#  &
s01 = {1, 2, 3}
s02 = {2, 3, 4}
print(s01 & s02)  # {2, 3}
2.并集:返回不重复元素
s1 = {1, 2, 3}
  	s2 = {2, 3, 4}
  	s3 = s1 | s2  # {1, 2, 3, 4}
# 并集
#  |
print(s01 | s02)  # {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)
# 补集
# ^
print(s01 ^ s02)  # {1, 4}
print(s01 - s02)  # {1 }
print(s02 - s01)  # {4 }
4.子集<:判断一个集合的所有元素是否完全在另一个集合中
5.超集>:判断一个集合是否具有另一个集合的所有元素
  	s1 = {1, 2, 3}
  	s2 = {2, 3}
	s2 < s1  # True
  	s1 > s2  # True
# 子集超集
s03 = {2, 3}
print(s03 < s01)

6.相同或不同== !=:判断集合中的所有元素是否和另一个集合相同。
 	s1 = {1, 2, 3}
  	s2 = {3, 2, 1}
  	s1 == s2  # True
  	s1 != s2  # False
子集或相同,超集或相同 <=  >= 
"""
    一个公司有如下员工
        经理:"曹操","刘备","孙权"
        技术员:"曹操","刘备","张飞","关羽"
    1. 选择数据结构,存储以上信息.
    2. 是经理也是技术的都有谁?
    3. 是经理也不是技术的都有谁?
    4. 不是经理也是技术的都有谁?
    5. 公司总共有多少人?
    6. 张飞是经理吗?
"""
dict_persons = {
    "经理": {"曹操", "刘备", "孙权"},
    "技术员": {"曹操", "刘备", "张飞", "关羽"}
}
print(dict_persons["经理"] & dict_persons["技术员"])
print(dict_persons["经理"] - dict_persons["技术员"])
print(dict_persons["技术员"] - dict_persons["经理"])
print(len(dict_persons["技术员"] | dict_persons["经理"]))
print("张飞" in dict_persons["经理"])

集合推导式

1.定义:
使用简易方法,将可迭代对象转换为集合。
2.语法:
{表达式 for 变量 in 可迭代对象}
     {表达式 for 变量 in 可迭代对象 if 条件}
"""
    列表 推导式
        [处理变量 for 变量 in 可迭代对象 if 条件]
    字典 推导式
        {处理变量 : 处理变量  for 变量 in 可迭代对象 if 条件}
    集合 推导式
        {处理变量 for 变量 in 可迭代对象 if 条件}
    适用性:
        根据可迭代对象,构建容器时.
"""
# 需求1:range(10)  --> key:0-9   value: key的平方
dict01 = {item: item ** 2 for item in range(10)}
print(dict01)

# 需求2:range(10)  --> key:0-9   value: key的平方
#        只考虑奇数
dict01 = {item: item ** 2 for item in range(10) if item % 2}
print(dict01)
"""
    推导式嵌套
        练习:exercise08
"""

list_fruits = ["香蕉", "苹果", "哈密瓜"]
list_drinks = ["可乐", "雪碧", "牛奶", "咖啡"]
# list_result = []
# for fruit in list_fruits:
#     for drink in list_drinks:
#         list_result.append(fruit + drink)
list_result = [fruit + drink for fruit in list_fruits for drink in list_drinks]
print(list_result)
# 色子 1 -- 6
# 色子 1 -- 6
# 色子 1 -- 6
# 将3个色子所有组合数存储到列表中

# list_result = []
# for x in range(1,7):#                 1           2
#     for y in range(1,7):#       1      2    ..
#         for z in range(1,7):#123456  123456
#             list_result.append((x,y,z))

list_result = [(x, y, z) for x in range(1, 7) for y in range(1, 7) for z in range(1, 7)]
print(list_result)
# 练习1:["齐天大圣","八戒","唐三藏"]-->key:字符  vlaue:字符长度
#      {"齐天大圣":4,"八戒":2,"唐三藏":3}
list_names = ["齐天大圣", "八戒", "唐三藏"]
dict_names = {item: len(item) for item in list_names}
print(dict_names)

# 练习2:["张无忌","赵敏","周芷若"] [101,102,103]
#      {"张无忌":101,"赵敏":102,"周芷若":103}
list_names = ["张无忌", "赵敏", "周芷若"]
list_rooms = [101, 102, 103]
dict_infos = {list_names[i]: list_rooms[i] for i in range(len(list_names))}
print(dict_infos)

# 练习3:将练习2的字典,key 与 value 颠倒
#       {101:"张无忌",102:"赵敏",103:"周芷若"}
dict_infos2 = {v: k for k, v in dict_infos.items()}
print(dict_infos2)
"""
    for for
    练习:exercise02
"""

# 外层循环控制行
for r in range(3):  # 0      1      2
    # 外层循环控制列
    for c in range(4):  # 0123   0123   0123
        print("老王", end=" ")
    print()  # 换行
"""
    4行5列
    *****
    #####
    *****
    #####
"""
for r in range(4):
    for c in range(5):
        if r % 2 !=0:
            print("*",end = "")
        else:
            print("#",end = "")
    print()


for r in range(4):
    for c in range(5):
        if c % 2 !=0:
            print("*",end = "")
        else:
            print("#",end = "")
    print()
"""
    for for 练习
"""
# 二维列表
list01 = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12],
]
# -- 打印第三行第二列数据      [行索引][列索引]
print(list01[2][1])

# -- 从右向左,打印第二行数据(一行一个)
for i in range(len(list01[1])-1,-1,-1):
    print(list01[1][i])

# -- 从上向下,打印第三列数据(一行一个)
# [0][2] [1][2] [2][2]
for i in range(len(list01)):
    print(list01[i][2])

# -- 将二维列表以表格状打印出来
# 1 2 3 4
# for r in range(len(list01)):
#     for c in range(len(list01[r])):
#         print(list01[r][c],end = " ")
#     print()

for line in list01:
    for item in line:
        print(item,end = " ")
    print()
"""
    矩阵转置
        算法:将list01中每列,存储到list02中每行
"""
list01 = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12],
]

list02 = []
# list01[0][0]
# list01[1][0]
# list01[2][0]

for c in range(len(list01[0])):
    line = []
    for r in range(len(list01)):
        line.append(list01[r][c])
    list02.append(line)

print(list02)
"""
    思想:
        将第一位元素,与后面元素进行比较,发现更小的则交换
           二
           三
           ...
"""

list01 = [4, 54, 5, 6, 7, 8, 3]

# list01[0]  list01[1]
# list01[0]  list01[2]
# list01[0]  list01[3]
# list01[0]  list01[4]
# for i in range(1,len(list01)):
#     # list01[0] 与 list01[i] 进行比较
#     pass

# list01[1]  list01[2]
# list01[1]  list01[3]
# list01[1]  list01[4]
# list01[1]  list01[5]
# for i in range(2, len(list01)):
#     # list01[1] 与 list01[i] 进行比较
#     pass

for r in range(len(list01) - 1):  # 0       1
    for c in range(r + 1, len(list01)):  # 123..   234..
        if list01[r] > list01[c]:
            list01[r], list01[c] = list01[c], list01[r]

print(list01)
"""
    list01 = [34,8,56,9,8,9]
    判断列表中是否具有相同元素True  False
    思想:
    将第一位元素,与后面元素进行比较,发现相同则打印结论
       二
       三
    如果所有元素比较后,也没有发现相同,则打印结论。
"""
list01 = [34, 8, 56, 9, 8, 9]
result = False  # 假设结论是没有重复
# 取数据
for r in range(len(list01) - 1):
    # 作比较
    for c in range(r + 1, len(list01)):
        if list01[r] == list01[c]:
            result = True
            break  # 退出一层循环
    if result:
        break

print(result)
"""
    list01 = [34, 8, 56, 9, 8, 9]
    删除列表中相同元素(重复元素只保留一个)
    要求:不使用集合
    算法:
        从后向前判断,如果相同元素(从前向后判断),则删除后面的元素.
"""
list01 = [34, 8, 56, 9, 8, 9]
# 取数据
for r in range(len(list01) - 1, -1, -1):
    # 作比较
    for c in range(r):
        if list01[r] == list01[c]:
            del list01[r]
            break  # 如果删除了后面元素,则无需继续用当前元素比较了

print(list01)

函数 function

pycharm快捷键:

Ctrl + P			参数信息(在方法中调用参数)
Ctrl + Q			快速查看文档
Ctrl + Alt + M		提取方法

定义

1.用于封装一个特定的功能,表示一个功能或者行为。
2.函数是可以重复执行的语句块, 可以重复调用。

作用

提高代码的可重用性和可维护性(代码层次结构更清晰)。

定义函数

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

调用函数

1.语法:函数名(实际参数) 
2.说明:根据形参传递内容。
"""
    函数
"""


# 代码的重复,是万恶之源

# 创建函数
def attack():
    """
        攻击
    """
    print("直拳")
    print("勾拳")
    print("侧踹")


# 参数:调用者  给  创建者 传递的信息
#      创建者 要求 调用者 提供的信息
def attack_repeat(count):  # 形式参数
    """
        重复攻击
    :param count:  int类型的 攻击次数
    """
    for __ in range(count):
        attack()


# 调用函数
attack()
attack_repeat(3)  # 实际参数
attack_repeat(10)

返回值

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

    函数创建者 给 调用者 传递的结果
"""

def func01():
    print("func01执行喽~")
    return 100 # return 数据

re = func01()

print(re)

def func02():
    print("func02执行喽~")
    # return  # return后没有数据或者没有return ,默认为None

re = func02()
print(re)

def func03():
    print("func03执行喽~")
    return # 退出函数
    print("func03又执行喽~")

func03()
"""
    函数返回值
        应用

    设计思想:小而精
"""
# 需求:定义函数,两个数值相加.

def add(number01,number02):
    """
        两个数值相加
    :param number01: 数值1
    :param number02: 数值2
    :return:数值类型,相加的结果
    """
    result = number01 + number02
    return result

# 测试
n1 = float(input("请输入第一个数字:"))
n2 = float(input("请输入第二个数字:"))
re = add(n1,n2)
print("结果是:"+str(re))
# 练习1: 定义函数,在终端中打印列表一个元素一行)
#  list01 = [43,4,5,78]
#  list02 = [76,6,579]

def print_list(list_target):
    """
        打印列表,将列表每个元素打印在终端中(一行一个)
    :param list_target:list类型,需要打印的列表
    """
    for item in list_target:
        print(item)


list01 = [43, 4, 5, 78]
list02 = [76, 6, 579]
print_list(list01)
print_list(list02)
# 练习:定义函数,在终端中根据边长打印矩形
#  day05/day04_exercse/exercise01

def print_rectangle(lenght, char):
    """
        打印矩形
    :param lenght:int类型 边长
    """
    print(char * lenght)
    for __ in range(lenght - 2):
        print(char + " " * (lenght - 2) + char)
    print(char * lenght)


# 测试
print_rectangle(5, "*")
print_rectangle(10, "$")
"""
    改造 day04/exercise01 代码
    定义函数,计算整数每位相加和
"""


def each_unit_sum(number):
    """

    :param number:
    :return:
    """
    sum_value = 0
    for item in str(number):
        sum_value += int(item)
    return sum_value


# 测试
print(each_unit_sum(1234))

"""
    改造 day03/exercise04 代码
    定义函数,根据成绩判断等级.
"""


# def calculate_score_level(score):
#     if score > 100 or score < 0:
#         return "不在范围内0-100"
#     elif 90 <= score:
#         return "优秀"
#     elif 80 <= score:
#         return "良好"
#     elif 60 <= score:
#         return "及格"
#     else:
#         return "不及格"

# 因为return 退出函数,所以无需else语句
def calculate_score_level(score):
    if score > 100 or score < 0:
        return "不在范围内0-100"
    if 90 <= score:
        return "优秀"
    if 80 <= score:
        return "良好"
    if 60 <= score:
        return "及格"
    return "不及格"

print(calculate_score_level(95))

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

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


# 将函数创建的代码加载到内存中(代码区)
# 备注:函数不执行
def func01():
    a = 1000


# 调用函数在内存中开辟空间(栈帧)
# 备注:存储在函数内部创建的变量
func01()


# 函数执行后栈帧销毁


# 结论:
#   不可变类型的数据传参时,函数内部不会改变原数据的值。
#   可变类型的数据传参时,函数内部可以改变原数据。

def func02(p1, p2):
    # 修改栈帧中变量存储的地址
    p1 = 100
    # 修改列表第一个元素存储的地址
    p2[0] = 200


a = 10  # 不可变对象
b = [20]  # 可变对象
# 将变量a,b存储的数据地址传入函数
func02(a, b)
print(a)  # 10
print(b)  # [200]

函数参数

实参传递方式argument

"""
    函数参数
        实际参数:调用者以何种方式传递数据
            位置实参
                -- 序列实参
            关键字实参
                -- 字典实参

位置传参

定义:实参与形参的位置依次对应。
def func01(p1, p2, p3):
    print(p1)
    print(p2)
    print(p3)


# 1. 位置实参:位置
func01(1, 2, 3)

序列传参

定义:实参用*将序列拆解后与形参的位置依次对应。
list01 = ["a", "b", "c"]
# 2.   -- 序列实参:拆
func01(*list01)

关键字传参

定义:实参根据形参的名字进行对应。
# 3. 关键字实参:名字
func01(p3=2, p1=1, p2=3)

字典关键字传参

1.定义:实参用**将字典拆解后与形参的名字进行对应。
2.作用:配合形参的缺省参数,可以使调用者随意传参。
# 4.  -- 字典实参:拆
dict01 = {"p3": "c", "p1": 1, "p2": "b"}
func01(**dict01)

形参定义方式parameter

"""
    形式参数:约束实参
        默认形参:可选
        位置形参:必选
            星号元组形参:合(位置实参)
        命名关键字形参:强制使用关键字实参
            双星号字典形参:合(关键字实参)
"""

缺省参数

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

位置形参

语法:
def 函数名(形参名1, 形参名2, ...):
函数体
# 1. 位置形参:必选
def func01(p1, p2, p3):
    print(p1)
    print(p2)
    print(p3)

星号元组形参

1.语法:
def 函数名(*元组形参名):
  函数体
2.作用:
收集多余的位置传参。
3.说明:
一般命名为'args'
形参列表中最多只能有一个
# 3. 星号元组形参: 合(位置实参)
# 备注:以args命名(不叫p1)
def func03(*p1):
    print(p1)


func03()
func03(34, 4, 5, 6, 7, 8)
list01 = [43, 54, 5, 6]
func03(*list01)  # 拆

命名关键字形参

1.语法:
def 函数名(*, 命名关键字形参1, 命名关键字形参2, ...):
函数体
def 函数名(*args, 命名关键字形参1, 命名关键字形参2, ...):
            函数体
2.作用:
强制实参使用关键字传参
# 4. 命名关键字形参:必须使用关键字实参
#   星号后面的形参是命名关键字形参
def func04(*args, p1, p2):
    print(args)
    print(p1)
    print(p2)


func04(1, p1=2, p2=3)
func04(p1=2, p2=3)

# 案例:print
#  print(*args, sep=' ', end='\n', file=None)
print("悟空", 25, 100, end=" ", sep="-")  # 悟空-25-100


# print("悟空",25,100," ","-")# 悟空-25-100

# p1 位置形参  p2 命名关键字形参
def func05(p1, *, p2):
    print(p1)
    print(p2)


func05(1, p2=2)
func05(p1=1, p2=2)

双星号字典形参

1.语法:
def 函数名(**字典形参名):
函数体
2.作用:
收集多余的关键字传参
3.说明:
一般命名为'kwargs'
形参列表中最多只能有一个
# 5. 双星号字典形参:合(关键字实参)
# 备注:以kwargs命名
def func06(**kwargs):
    print(kwargs)

func06()
func06(a=1, b=2, c=3)

参数自左至右的顺序

位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
# 1.
def func01(p1, p2):
    p1 = ["孙悟空"]
    p2[0] = ["猪八戒"]


a = ["悟空"]
b = ["八戒"]
func01(a, b)
print(a)  # ['悟空']
print(b)  # [['猪八戒']]


# 2.
def func02(p1, p2):
    p2[:] = "孙悟空"
    p1[:] = p1[::-1]


a = [10, 20, 30]
b = ["a", "b", "c"]
func02(a, b)
print(a)
print(b)
"""
    改造day07/exercise04代码
    定义 矩阵转置 函数

    改造day08/day07_exercise/exercise04代码
    定义 方阵转置 函数
"""


def matrix_transpose(list_matrix):
    """
        矩阵转置
    :param list_matrix:
    :return: 新矩阵
    """
    list_result = []
    for c in range(len(list_matrix[0])):
        line = []
        for r in range(len(list_matrix)):
            line.append(list_matrix[r][c])
        list_result.append(line)
    return list_result


# 测试
list01 = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]
print(matrix_transpose(list01))
def square_matrix_transpose(square_matrix):
    for c in range(len(square_matrix) - 1):
        for r in range(c + 1, len(square_matrix)):
            # 3. 修改可变对象
            square_matrix[r][c], square_matrix[c][r] = square_matrix[c][r], square_matrix[r][c]
    # 3. 无需通过 return 返回结果
    # return square_matrix

# 测试
list01 = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [9, 10, 11, 12],
]
# 1. 传入可变对象
# print(square_matrix_transpose(list01))
square_matrix_transpose(list01)
"""
    改造day07/exercise07代码
    定义 删除列表中相同元素 函数

    体会:传入可变对象、修改可变对象、无需返回值
"""


def delete_duplicates(list_target):
    """

    :param list_target:
    :return:
    """
    count = 0
    for r in range(len(list_target) - 1, -1, -1):
        for c in range(r):
            if list_target[r] == list_target[c]:
                del list_target[r]
                count += 1
                break
    return count

# 测试
list01 = [34, 8, 56, 9, 8, 9]
print(delete_duplicates(list01))
print(list01)
"""
    改造day07/exercise05代码
    定义 排序 函数
    体会:传入可变对象、修改可变对象、无需返回值 
"""

def sort(list_target):
    """

    :param list_target:
    :return:
    """
    for r in range(len(list_target) - 1):  # 0       1
        for c in range(r + 1, len(list_target)):  # 123..   234..
            if list_target[r] > list_target[c]:
                list_target[r], list_target[c] = list_target[c], list_target[r]

list01 = [4, 54, 5, 6, 7, 8, 3]
sort(list01)
print(list01)
"""
    改造day03/exercise05代码
    定义 根据月份计算天数的 函数
"""


def is_leap_year(year):
    """
        判断是否为闰年
    :param year:
    :return:
    """
    return year % 4 == 0 and year % 100 != 0 or year % 400 == 0


def get_day_by_month(year, month):
    """
        获取天
    :param year:
    :param month:
    :return:
    """
    if month < 1 or month > 12:
        return 0
    if month == 2:
        return 29 if is_leap_year(year) else 28
    if month == 4 or month == 6 or month == 9 or month == 11:
        return 30
    return 31
# 练习: 质数:大于1的整数,除了1和自身以外,不能被其他数字整除
#     定义函数,获取指定范围内的所有质数.
#     例如:2 ~ 20
#      [2,3,5,7,11,13,17,19]

# def get_primes(begin, end):
#     list_result = []
#     for number in range(begin, end + 1):  # 7
#         for item in range(2, number):  # 2 3 ...6
#             if number % item == 0:  # 7  % 2
#                 # 不是质数
#                 break
#         else:
#             # 是质数
#             list_result.append(number)
#     return list_result

def is_prime(number):
    for item in range(2, number):
        if number % item == 0:  # 7  % 2
            return False
    return True

def get_primes(begin, end):
    # list_result = []
    # for number in range(begin, end + 1):
    #     if is_prime(number):
    #         list_result.append(number)
    # return list_result
    return [number for number in range(begin, end + 1) if is_prime(number)]

# 测试
print(get_primes(2, 20))
# 练习:定义函数,根据时,分,秒,计算总秒数.
# 测试:
#   时,分,秒 --> 总秒数
#   时,分 --> 总秒数
#   分 --> 总秒数
#   时,秒--> 总秒数
def get_total_second(hour=0, minute=0, second=0):
    return hour * 3600 + minute * 60 + second


# 1时,2分,3秒 --> 总秒数
print(get_total_second(1, 2, 3))
# 1时,2分 --> 总秒数
print(get_total_second(1, 2))
# 2分 --> 总秒数
print(get_total_second(minute=2))
# 1时,3秒--> 总秒数
print(get_total_second(1,second=3))
# 练习:定义函数,数值相加的函数.
# 测试:1,2
#      1,2,5,54,65,6,
def sum_numbers(*args):
    # sum_value = 0
    # for item in args:
    #      sum_value += item
    # return sum_value
    return sum(args)

print(sum_numbers())
print(sum_numbers(1, 2, 3, 54, 4, 56, 6, 7))

作用域LEGB

1.作用域:变量起作用的范围。
2.Local局部作用域:函数内部。
3.Enclosing  外部嵌套作用域 :函数嵌套。 
4.Global全局作用域:模块(.py文件)内部。 
5.Builtin内置模块作用域:builtins.py文件。

变量名的查找规则

1.由内到外:L -> E -> G -> B
2.在访问变量时,先查找本地变量,然后是包裹此函数外部的函数内部的变量,之后是全局变量,最后是内置变量。

局部变量

1.定义在函数内部的变量(形参也是局部变量)
2.只能在函数内部使用
3.调用函数时才被创建,函数结束后自动销毁

全局变量

1.定义在函数外部,模块内部的变量。
2.在整个模块(py文件)范围内访问(但函数内不能将其直接赋值)。

global 语句

1.作用:
在函数内部修改全局变量。
在函数内部定义全局变量(全局声明)。
2.语法:
global 变量1, 变量2, …
3.说明
在函数内直接为全局变量赋值,视为创建新的局部变量。
不能先声明局部的变量,再用global声明为全局变量。

nonlocal 语句

1.作用:
在内层函数修改外层嵌套函数内的变量
2.语法
nonlocal 变量名1,变量名2, ...
3.说明
在被嵌套的内函数中进行使用

你可能感兴趣的:(python基础笔记一)