Bash
# -- coding: utf-8 --
# @Time : 2022/8/11 16:08
# python 第二章
变量
python变量：变量是计算机内存中的一块区域，存储固定范围内的值，值可以改变，通俗的
说变量就是给数据起个名字。
1.python 变量是不需要声明的
2.python的变量是没有类型的，类型是属于变量的值
3.python变量的复制操作即是变量声明也是定义过程
4.多个变量赋不同的值
5.严格区分大小写
python常量：其值在程序运行过程中保持不变的量
python变量赋值 ‘=’
a = b = 1 # 多个变量赋值
a = '王丽' # 单个变量赋值
x, y, z = 1, 2, 3 # 多个变量赋值
A = 'a' # 严格区分大小写
# print(x,y,z)
a = [1, 3]
a = (1, 3)
a = {'a': '1'}
标识符
标识符概念：开发人员在程序中自定义的一些符号和名称。标识符是自己定义的，如变量 名，
函数名等
python 标识符规则
1.由字母、数字、下划线组成
2.不能以数字开头
3. 不能以关键字作为标识符
4.标识符区分大小写
python关键字：
python中一些具有特俗功能更的标识符，这就是python中的关键字。是python已经使用的，
所以不允许开发者自己定义和关键字相同的名字作为标识符
在python中，可以通过一下命令查看当前系统中python的关键字
mport keyword
print(keyword.kwlist)
标识符明明规则：
1.见名知意 起一个有意义的名字，尽量做到看一眼就知道是什么意思（提高代码的可读性），
常用英文单词。如：名字，就定义为name；定义学生 用student
2.驼峰命名法（大驼峰命式名法，小驼峰式命名法，下划线式命名法）
StudentAge = 20 # 大驼峰
studentAge = 20 # 小驼峰
student_age = 21 # 下划线
student_info_table_address = '地址表'
python 数据类型
标准数据类型
number(数字) ----> Int(整型) Float(浮点型) Bool(布尔型) Complex（复数）
a = 10 # int 类型
b = 3.14 # float 类型
c = True # bool T或者F 必须大写 True = 1 False = 0
d = 5 + 3j # complex 类型
# import sys
# print('内存空间大小：',sys.getsizeof(a))
# print('内存空间大小：',sys.getsizeof(b))
Sting(字符串)
一下几种都是可以
str1 = '好好学习'
str2 = "天天向上"
str3 = '''坚持'''
str4 = """奋斗"""
# 推荐使用单引号、双引号
# 注意转义字符 \n 换行 \t 一个tab位
# 字符串切片（截取指定的内容）
# str5 = 'hello world'
# print(str5[6]) # 取指定的下标值
# print(str5[0:5]) # 截取一段字符串，包前不包后
# print(str5[6:]) # 从某个小标开始截取到末尾
# print(str5[:5]) # 从开头开始到某个借宿
# print(str5[-5:]) # 从右往左
# 字符串操作 ：+ ，*
# str6 = '张三'
# print(str6+'是个正直的人') # 连接
# print(str6*3) # 复制
# 字符串常用的方法
# str7 = 'hello world'
# print(str7.capitalize()) # 首字母大写，其它小写
# print(str7.upper()) # 全大写
# print(str7.lower()) # 全小写
# print(str7.replace('o','Y')) # 将0替换程k
# print(str7.replace('o','@',2)) # 数字表示替换的个数
# # 分割
# str8 ='小狗、小猫、小马、小鸡、小熊' # 分割之后的返回值式list
# print(str8.split("、"))
# 字符串格式输出 %s %d %f
# name = '张三'
# age = 20
# score = 78.65123
# print('我叫%s，今年%d岁'%(name,age)) # %占位符，后面式类型
# print('我叫{}，今年{}岁'.format(name,age))
# print('分数是：%.2f'%score) # 指定精度
List(列表)
# 特点：
# 1.可变数据类型
# 2.可以存放多种数据类型
# 3.有下标，从0开始 python中有下标就可以切片
# 4.数据可以重复
list1 = ['张三', 80, True, '李四', 5.123498, [1, 2, 3]]
list2 = [a, b, c]
# print(type(list1),list1)
# # 切片
# print(list1[2:5])
# # list的*和+
# print(list1+list2) # +连接两个变量
# print(list1*2) # 复制变量
# 不可变数据类型：number string tuple
# 可变数据类型: list dic set
# 是指变量的值发生改变时是否在原有的内存空间进行
# python中多个变量值相同的话，他们指向同一个内存地址
# 同一个变量，值不同，内存地址不同是将原来的内存地址丢弃，再重新给一个内存地址
# 不可变数据类型
# a = 5
# print(id(a))
# a = 8
# print(id(a)) # 产看变量的内存地址，
# a = 5
# print(id(a))
# b = 5
# print(id(a))
# 可变数据类型
# 可变类型多个变量数值相同，内存地址四不一样的
# 在原有的数据类型修改，改数据类型的内存地址不变
# lista = [1,2,3]
# listb = [1,2,3]
# print(id(lista))
# print(id(listb))
# lista[0] = '张三'
# print(id(lista))
# 列表常用的操作
'''
list1 = [1, 2, 3,'李四']
list1.append('张三') # 追加
print(list1)
list1.insert(1, '李四') # 在指定位置插入
print(list1)
print(list1.pop()) # 返回最后一个元素，并从list中删除
print(list1)
list1.remove('李四') # 删除第一次出现的元素
print(list1)
print(list1.count(2)) # 统计元素出现的个数
print(list1.index('李四')) # 获取下标
list2 = ['a','b']
list1.extend(list2) # 将list2的元素都追加到list1中
print(list1)
'''
# 排序、反转
# score = [65,90,23,78,33]
# score.sort()
# print(score)
# score.reverse()
# print(score)
# 复制
# 1.取别名，内存地址相同
'''
list3 = ['a','b']
test1 = list3
print(list3,id(list3))
print(test1,id(test1))
'''
# 2.克隆，内存地址不同
'''
list4 = [1,2,3,4,5,5]
list5 = list4[:]
print(list4,id(list4))
print(list5,id(list5))
'''
Tuple(元组):元素类似于list(列表)，的另一个数据类型
元素用() 表示，内部元素用都好隔开。但是元素不能二次赋值，相当于只读列表
特点：
1.不能二次赋值
2.可以存放多种数据类型
3.数据可以重复
4.有下标，从0开始
tup1 = () # 空元组
tup2 = (2,) # 只有一个元素，需要添加逗号，否则就不是元组类型
# print(type(tup1))
# print(type(tup2))
'''
tup3 = (3,'张三',5,12,True,3,'张三',[1,2,3])
print(tup3,type(tup3))
# tup3[1] = 100 # 元组不能二次赋值，创建的时候赋好值了，则不能再次赋值了
print(tup2+tup1) # 两个元组新加，则重新生成一个新的元组
print(tup3*3)
# 常用方法
print(tup3.index(True))
print(tup3.count(3))
print(len(tup3))
'''
Sets（集合）
特点：
1、可变数据类型
2、可以存放多种数据类型 [不支持list,set,dict]
3、数据不能重复
4、无下标，无序
'''
set1 = () # 创建空集合，必须是()
set2 = {1,'张三',3,True,2.89,'张三'}
print(set2)
set2.add('李四')
print(set2)
'''
# 集合的而运算
'''
set3 = {1,2,4,3,4,5}
set4 = {6,7,9,0,4,5}
print(set3-set4) # set3 和 set4的差集 ，即set3存在set4不存在的元素
print(set4-set3) # set4 和 set3 的差集 ，即set4存在set3不存在
print(set4 | set3) # set4 和 set3的并集，即set3和set4中不重复的所有元素
print(set3 & set4) # set3 和 set4的交集 ,即 set3 和set4中都存在的于是怒
print(set3 ^ set4) # set3 和 set4 不同时存在的元素
'''
# 成员判断in
'''
set4 = {6,7,9,0,4,5}
print(6 in set4)
print(3 not in set4)
'''
Dict（字典）
特点
1、元素都是键值对 key:value ---> 'key':'value' ---> 'name':'张三'
2、无序，没下标
3、可变数据类型
4、key相同会默认取最后一个值
'''
info = {'name':'张三','age':20,'like':{'name':'小红'}} # 可以字典套字典
print(info)
# 操作方法
print(info['like']) # 通过key获取
info['sex'] = '男' # 添加元素
print(info)
info['sex'] = '女' # 修改元素
print(info)
del info['sex'] # 删除某个键值对，如果不写key，则是删除整个字典
print(info)
'''
方法
'''
info2 = {'name':'张三','age':20,'like':{'name':'小红'}}
print(info2.keys()) #获取所有的key
print(info2.values()) # 获取所有value
# info2.clear() # 清空整个字典
print(info2)
print(info2.get('name')) # 通过key获取value
print(info2['name']) # 通过key获取value
# print(info2['jj'])
print(info2.get('33','key error')) # 当key不存在的时候返回 key error 或默认返回 None
print(info2.pop('name','key error')) # 删除并返回key对应的值，当key不存在则给定返回的值
print(info2)
info3 = {'class':'T14','num':20}
info2.update(info3) # 将info3的元素都添加到info2中
print(info2)
'''
不可变的数据（三个）：Number（数字）、String（字符串）、Tuple（元组）、
可变数据（三个）：List（列表）、Dictionary（字典）、Sets(集合)
类型转换：前提条件是两种类型之间相互兼容
1、自动转换/隐式转换:由低精度向高精度转换
a = 5
b = 4.125
2、强制转换: 类型(值)
c = '10'
print(a+b+float(c))
进制转换 int(值，进制)
'''
d = '123'
e = '11111111'
print(int(d))
print(int(e,2)) # 2进制转10进制
print(int(e,8)) # 8进制转10进制
print(int(e,16)) #16进制转10进制
'''
int 和 chr()转换
'''
A = 65
a = 97
print(chr(A),chr(a))
'''
字符转数字用ord()
'''
A = 'A'
a = 'a'
print(ord(a),ord(A))
'''
'''
python 序列操作
序列包含：字符串、列表、元组。
序列的两个特征是”索引“和”切片“，索引：根据Index获取特定元素：切片：获取序列片段。
常见序列操作：
len():求序列的长度 +：连接两个序列
*:重复序列元素 in：判断元素在序列中
max():返回序列最大值 min()：返回序列最小值
'''
# 举例：
'''
score1 = [40,80,21,46,23,100,57]
score2= [40,80,21,46,23,100,57]
print(len(score1))
print(score2+score1)
print(score1*3)
print(40 in score1)
print(min(score1))
print(max(score1))
'''
python输入输出语句
python 输入语句
在python 3.x 中raw_input()和input()进行了整合，去除了raw_input(),
保留了input()函数，其接收任意输入，将所有输入默认字符串处理，并返沪字符串类型
# example:
'''
str01 = input('请输入：')
print(type(str01),str01)
'''
# python输出语句；
# python 中使用print()函数进行输出，如果希望输出的形式更加多样，
# 可以使用str.format()函数,不需要管数据类型，
# 来格式化输出值。
# example:
'''
print('hello')
print('{}网址："{}!"'.format('自动化测试','www.baidu.com'))
# 括号以及里面的字符(称为格式化字段)将会被format()中的参数替换。
# {}中的数字参数表示下标
print('{0},{1}'.format('hello','world')) # 括号中数字
# {}中的变量名，需要在参数列表中给它赋值
print('{name}说：{concent}'.format(name = '小红',concent = '你好') )# 括号中的关键字)
'''
python 运算符与表达式
# 运算符是通过一定的运算规则操作一个火多个操作数，并生成结果的特定符号；
# 运算符和操作数的有效组合称为表达式。
# python 提供了一系列的运算符，包括：
# 算术运算符
# 运算符 说明
# + 加法： a+b
# - 减法： a-b
# * 乘法： a*b
# / 除法 a/b
# % 取模 a%b
# // 整除： a//b
# ** 幂 a**3
# 举例：
'''
a = 10
b = 2
print(a+b)
print(a-b)
print(a*b)
print(a/b)
print(a//b)
print(a % b)
print(a**3)
# 运行结果：
12
8
20
5.0
5
0
1000
'''
赋值运算符
= 在程序中是赋值运算符，其作用是获取右边的值，赋给左边；
右边可以是任何有结果的表达式，常量或者变量；
对于基本数据类型赋值很直接，是实际的值复制一份给接收的变量存储，对这个值的任何后续
修改都不会影响其它变量；
对于引用数据类型的赋值则不同，由于引用数据类型的变量实际保存的是一个指向实际值的地址，
所以使用=的结果只是将地址交给接收的变量，让这个变量也引用这个空间，如果这个空间的值被修改，
所有引用这块空间的变量都会影响
运算符 说明
= 赋值 ： a = 1, a = b
+=、-= a = a + b 可以写成 a+=b 、a = a-b
*=、/= a = a*b 可以写成a*=b 、a = a/b 可以写成 a/=b
%= a = a % b 可以写成 a%=b
//= a=a//b 可以写成 a//=b
注意 python 中没有++，--
'''
c = 4
c += 1 # c = c=1
c *= 2
print(c)
'''
关系运算符
可以测试两个操作之间的关系（但不会改变操作数的值），关系表达式的结果为boolean
类型 true/false。
运算符 说明
== 检测两个数的相等性
！= 检测两个数的不等性
> 检测左边的值是否大于右边的值
< 检测左边的值是否小于右边的值
>= 检测左边的值是否大于或等于右边的值
<= 检测左边的值是否小于或等于右边的值
结果是bool类型
'''
print(5 == 2)
print(5 > 2)
print(5 != 2)
'''
逻辑运算符: and , or , not
'''
a = 5
b = 10
c = 8
print(a < b and a < c) # 两个都为真才为真
print(a < b or a < b) # 1个为真结果为真
print(not a > c) # 取反
'''
位运算符
三元运算符： ...if...elese ...
又称为条件运算符，根据判定条件指向语句
当if后面的条件为真就指向if前面的语句，为假就执行else后面的语句
'''
a = 10
b = 20
print(a if a > b else b)
'''
身份运算符: is 、 is not 比较内存地址是否相同
比较两个对象的内存位置。
'''
a = 5
b = 5
c =2
print(a is b )
print(a is c)
'''
成员运算符 in 、not in
测试给定值是否有序列中成员，例如字符串，列表或元组
'''
str1 = '张三李四王二麻子'
print('张三' in str1)
print('王五' not in str1)
'''
运算符 说明
...if ...else ... 5 if 5>3 else 3 为真时的结果 if判断条件 else 为假时的结果
in 如果在指定的序列中找到值返回True,否则返回False
not in 如果指定的序列中没有找到返回值返回True,否则返回False。
is 判断两个标识符是不是引用自一个对象
is not 判断两个标识符是不是引用不同的对象
python 运算符优先级
很多情况下，一个表达式由多个运算符组成，优先级决定运算符的计算顺序
'''
运算符 描述
** 指数（优先级最高）
~ + - 按位翻转，一元加号和减号（最后两个的方法名为+@和-@）
*/%// 乘 除 取模和整除
>> << 右移，左移运算符
& 位"AND"
^| 位运算符
<= >= < > 比较运算符
= %= /= //= += -= *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符
'''
python 代码缩进与多行语句
代码缩进：
学习python与其它语言最大的区别就是，python的代码块不适用{}来控制类，函数以及其它
逻辑判断
python最具有的特色就是用缩进来写模块
空白在python忠告是周昂要的。事实上行首的空白是周昂要的。它称为缩进。在逻辑行首的空白（空格
和制表符）用来决定逻辑的缩进层次，从而用来决定语句的分组。
这意味着同一层次的语句必须有相同的缩进。每一组的语句称为一个块。
备注：缩进必须严格执行，或者代码报错
多行语句
python 中一般以鑫行作为语句的结束符。
根据代码规范，一般一行包含80-100个字符，当代码在一行中写不下的时候，我们可以使用
斜杠（\）将一部分语句分为多行显示。
如果语句中包含[]、{}或()就不需要使用多行连接符
# python 控制流语句
# 程序设计中的控制语句由3种，即顺序、分支和循环语句
#
# 顺序结构：
# 语句的执行顺序是按照程序语句书写的顺序，从上到下依次执行。
#
# 选择结构：
# 是指下一步执行语句由多个选择分支，程序执行流程根据当前的状态，选择其中一个分支
# 执行
#
# 循环结构：
# 是指如果满足一定条件，则反复执行一段程序，直到条件不满足为止。
# python 分支语句
# python 条件语句是通过一条或多条语句的执行结果了(True或者False)来决定执行
# 的代码块。
# python 陈旭语言指定任何非 0 和非空（none）、True 值为逻辑真，0或者none、
# False为逻辑假。
# python 编程中if语句用于控制程序的执行。
#
# 基本形式为：
# if 判断条件
# 执行语句...
# else:
# 执行语句 ...
# 其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分
# 表示统一泛微。
# else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句。
# if判断语句
# if 表达式
# 语句块1
# else:
# 语句块2
'''
name = input('请输入你的姓：')
str1 = '王、李、张、刘、陈、杨、黄、赵、周、吴、徐、孙、马、胡、朱、郭、何、罗、高、林'
if name in str1:
print(name)
else:
print('您输入的姓不存在本系统')
'''
# 判断红绿灯的颜色（红，黄，绿），然后输出行相应的提示
'''
color = input('请红绿灯输入颜色：')
if color == '红':
print('禁止通行')
elif color == '黄':
print('慢行')
elif color == '绿':
print('可以通行')
else:
print('您输入的红绿灯颜色不存在哦！')
'''
# python 循环语句
# for 循环语法如下：
# for 迭代变量 in 可迭代对象:
# 执行语句...
# [else:
# 执行语句 ...]
# 每次循环，迭代变量被设置为可迭代对象（序列，迭代器，或者式其他支持迭代的对象）
# 的当前元素，提供执行语句
# 举例：
'''
for letter in 'Python':
print('当前字母是：',letter)
fruits = ['banana','apple','mango']
for fruit in fruits:
print('当前的水果是：',fruit)
'''
# while 循环的语法如下：
# while 判断条件：
# 执行语句....
# [else:
# 执行语句....
# ]
# 执行语句可以是单个语句或语句块，判断条件可以是任何表达式，任何非零、或非空（null）
# 的值为true。当判断条件为false时，循环结束。else这种的语句会再循环正常执行完。
# 举例：
# i = 10
# count = 0
# while i > 0:
# count = count+1
# i = i-1
# else:
# print(count)
# while 循环：先判断再执行循环体
# while 条件；
# 循环体语句块
# else:
# 语句块
# 输出6个我爱学习
# i = 1
# while i <7:
# print('我爱学习')
# i+=1
# 实现从1+3+5+...+19的和
'''
i = 1
sum1=0
while i <20:
sum1 += i
i = i+2
print(sum1)
'''
# for 循环语法如下：
# for 迭代器 in 可迭代对象：
# [else:
# 执行语句...]
# 每次循环，迭代变量被设置为可迭代对象(序列，迭代器，或者是其他支持迭代的对象)的当前
# 元素，提供执行语句块使用，直到可迭代对象遍历完成终止。
# 举例：
# for letter in 'Python':
# print('当前字母：'+letter)
# fruits = ['banana','apple','mango']
# for fruit in fruits:
# print('当前字母：',fruit)
# for 循环，遍历
# for 变量 in 可遍历的对象：
# 循环体语句块
# else:
# 语句块
'''
names = ['张三','李四','王五']
for name in names:
print(name)
'''
# 实现输出5个’我爱你
'''
for i in range(0,5): # range() 函数，生成数字序列，默认从0开始，生成0-5，最后一个是取不到的
print('I L ove you！')
for i in range(0,20,2): # range() 第三个参数是步长
print('I L ove you！')
'''
# break 语句：
# 用来终止循环语句，即循环条件没有False体哦阿健或者序列还没被完全递归完，也会停止执行
# 循环语句。break语句用在while和for循环中。
# 如果使用嵌套循环，break 语句将停止执行最深层次的循环，并开始执行下一行代码。
#
# continue语句：
# 用来告诉python 跳过当前循环的剩余语句，然后继续进行下一轮循环。
# continue 语句用来while和for 循环中
#
# else 语句：
# 在python 中,for .... else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句
# 会在循环中正常执行完（即 for 不是通过break 跳出而中断的）的情况下执行，while ... else 也是
# 一样。
#
# pass 语句：
# 是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用作扎内府。
# break 跳出整个循环，结束整个循环
# continue 跳出档次循环，后面的循环会继续
'''
name = ['张三','李四','王五','狗蛋']
for n in name:
if n == '李四':
continue
# break
else:
pass # 空语句，占位符，保证语法的完整性
print(n)
'''
# python 循环嵌套：
# python 语言允许在一个循环体里面嵌入另外一个循环。
# python for 循环嵌套语法：
# for iteration_var in sequence:
# for iteration_var in sequence:
# statement(s)
# statements(s)
'''
python while 循环嵌套语法:
while expression:
while expression:
statements(s)
statements(s)
也可以在循环体内嵌入其他的循环体，如在while 循环中可以嵌入for循环，反之，你可以
在for循环中嵌入while 循环
'''
# 冒泡排序
# 将分数从高到低进行排序，
'''
score1 = [66,45,50,35,60,23]
print('原始数据：',score1)
for i in range(len(score1)-1): # 轮数 0,1,2,3,4,5
for j in range(len(score1)-i-1): # 控制次数
if score1[j] < score1[j+1]: # 比较2个相邻的数大小
score1[j],score1[j+1] = score1[j+1],score1[j]
print('第 {} 轮: '.format(i+1),score1)
'''