《Python基础语言 二 》— Echo版

已于 2024-05-16 09:55:51 修改
阅读量1k 收藏 8
点赞数 24
CC 4.0 BY-SA版权
分类专栏： Python基础语法 文章标签： python
于 2024-05-07 11:09:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/if_Echo_else/article/details/138524544

二、Python

8. Python入门仪式

写Python程序方式1
 可以自定义python文件, 文件的后缀名是.py
 在控制台上可以通过python解释器 向计算机解释python程序
写Python程序方式2
	在控制台上 借助指令python进入到python环境中 在环境中书写程序
写Python程序方式3
	借助编辑器[Python提供的编辑器idle 或者 使用Pycharm]

向Python世界say Hello

简单而言 借助python程序输出hello world

print
	输出的时候 不同的数据 书写格式是不一样的 对应的数据类型是不一样的
		具有相同特征的鬼节为一个类型的数据

	简单的数据类型
		整型数据int --- 数据全部都是整数
		浮点型数据float --- 数据全部都是小数
		布尔类型数据bool --- True/False
		字符串类型数据str ---
			如果数据是单个或者多个字符拼在一起的 就是字符串类型
			标识是引号 不区分单双引号
			注意:要输出多个字符或者单个字符 需要使用引号包含 而不能直接使用符号
				"hello world" 正确的
				hello world 错误的

print的使用
	help帮助功能 可以查看使用的功能的方式

	 print(values, sep=' ', end='\n', file=sys.stdout, flush=False)

values:
	表示输出的数据 - 可以输出多个数据 每个数据之间使用逗号分开即可 [注意写程序所有点符号都是在英文状态下的]
		>>> print(10)
     10
     >>> print(10, 3.14)
     10 3.14
     >>> print(10,3.14,True,"hello world")
     10 3.14 True hello world
	   >>>	
sep 
	默认值是空格符号
	设置的是当输出多个数据时 每个数据之间的分隔符
	可以进行自定义
	>>> print("h","e","l","l","o")
   h e l l o
   >>> print("h","e","l","l","o",sep="")
   hello
   >>>
end
	\表示的是转义符  用于转义\后面的符号
		\n --- 把n换成了换行的意思
	默认值是换行
	作用: 执行多条输出语句时[写了多个print] 每个print输出的内容是以换行结尾的
	如果一行有多个语句[单独的一个功能], 语句之间使用分号隔开
file ----> 表示的是 默认将内容输出到控制台
	更改:将输出的内容存于到指定文件里
		前提需要打开一个文件 打开模式设置写入w的状态
			打开模式:
				r --- 读取文件 read
				w --- 写入文件 write  >
				a --- 写入文件 append >>
flush----> 输出的内容是否及时刷新

9. 编程语言的描述

程序员需要与计算机进行交互, 进而完成对应的功能

能完成交互前提是 程序员需要使用计算机识别的语言来沟通

计算机中的数据是二进制格式的

人们制定了一种规范去和计算机进行交互, 这个规则对应的语法就是编程语言

学习编程语言 其实学习的就是语法规则

语法: 制定好的固定格式 使用这个语法直接嵌套就可以了

10. Python发展史

Python底层是通过C语言来完成 1991年正式发布的 研发者是一个荷兰人 “硅叔” 1989年

1999年 支持了网站开发 爬虫开发

2000年出现了python2.0版本

2004年出现了python2.4版本 — Django出现了

2008年出现了Python2.6

2.x中的输出的格式: print "hello world"

3.x中的输出格式: print("hello world")

2008年底的时候出现了python3.0 — 与2.x的版本完全不兼容

2010年的时候出现了2.7的版本 — 向3.0的过度

2020年不再对2.x的版本进行维护 学习的是3.x的版本

现在不要使用3.7 第二阶段Django 使用的版本1.x的版本 长久版 不兼容3.7

11. 注释

用自己的语言 来描述代码的功能使用 便于自己后期的理解

因为现在接触的代码全部都是英文的

注释的格式:

​ 单行注释 — 只能注释掉一行内容

​ 格式: #注释内容

​ 多行注释 — 三对引号[引号不区分单双]

​ 格式: ''' 注释内容 '''

建议对自己的代码多加注释

12. 变量

变量的概念:

​ 某个内容的值是变化的

小学知识 一元一次方程

​ 题目:

​ 车a在马路上以80km/h的形式速度匀速形式 问多少小时后 行驶1000km??

​ 解: 设x小时后行驶1000km

​ 80 * x = 1000

​ x = 1000/80 = 12.5

设置的x就是一个变量 根据不同的题意 x对应的内容是不同的

变量对应的数据是变化 如果想获取这个数据 不能准确的获取 但是可以通过x获得对应的值

​ 车b在马路上行驶 100km/h a行驶1000km后 b开始出发 问b多长时间追上a

​ 设y小时后 b追上a

​ 80 * x + 80 * y = 100 * y

​ 80 * 12.5 + 80 * y = 100 * y

​ 20 * y = 1000

​ y = 50

变量的作用:

​ 存储运算过程中一些变化的数据的结果的,便于后面的其他情况的使用

在程序中对变量的解释:

​ 内存:

​ 把他比作成高楼大厦, 分布着很多小的房间[比作成字节],数据占用的是字节,如果有多个字节,可以理解成将这个多个小房间打通称为一个地址,高楼大厦中每个房间都有字节标号[地址]

​ 在内存中查找某个数据, 该数据对应的地址查找比较方便快捷的

​ 比如:外卖人员给你送外卖, 北京市当做内存 外卖人员通过地址定位到送货位置的

​ 变量的解释:

​ 变量是来存放数据的,数据是在内存中开辟对应的字节数来存放的,这个数据就有一个对应的地址,把这个地址给设置给对应的接收者, 通过接收者接受到地址获取其对应的数据,这个接受者会有一个名字, 这个名字称之为变量名

这个变量名是程序员自己定义的, 程序中程序员自己定义的名字需要遵守一些规范, 这个规范称之为标识符

规范:

标识符的组成: 数字 字母  下划线
组合的时候注意事项:
	1. 自定义的名字不能以数字开头
	2. 自定义的名字不能使用Python中占用的名字[关键字] 和 备用的名字
			----> 只要python使用了 咱们就不能再使用  如果使用会将python中提供的原有意义给覆盖掉, 如果再想使用原有意义就使用不了了
	3.尽量做到见名思意

现在接触到的自定义名字有哪些??
	1.自定义python文件名
		规范:英文字母全部是小写的, 每个单词之间使用下划线隔开
			first_demo
	2.自定义变量名
		规范:英文字母全部是小写的, 每个单词之间使用下划线隔开
			max_value
	3.自定义项目的名字
		规范: 单词的每一个英文字母大写  遵守的是大驼峰
			FirstProject

在Python中声明变量的时候的注意事项:
	1. 在使用该变量之前必须先进行声明 并赋予初始值 [定义出来]
	2. 变量声明的格式:
		a.声明一个变量:
			x = 10
			或者
			x:数据类型
			x = 10
			例如:
			7变量的声明
              #1. 声明立即进行初始化
              x = 10
              print("x")
              print(x)
              '''
              在使用一个符号的时候 加引号和不加引号的区别:
                  加上引号 这个符号表示的是一个字符串类型的数据
                  不加引号 这个符号表示的是一个变量名  要使用的是他对应的数据
              '''


              #2. 声明先不赋予初始值 再使用之前赋予
              y:int
              y = 10
              print(y)
           b.声明多个变量
          		i.多个变量的值是相同的
            		x = y = z = 10
              	ii. 多个 变量的值是不同的
                	x, y, z = 10, 11, 12

13. 数据类型的初见

不同的特征的数据 对应者不同的数据类型

系统提供的数据类型:

  • ​ 针对于数值的数据类型 : 整型 浮点型 复数型[很少用]

  • ​ 布尔类型 : 用于标记状态的 成立或者不成立 只有两个值 True和False

  • ​ 字符串类型 : 容器, 存放的多个字符,使用引号包含单个或者多个字符的

  • ​ 列表类型 : 容器 可以存放多个变量的数据

  • ​ 元组类型 : 容器, 也可以存放多个变量

  • ​ 字典类型 : 容器 存放的是具有映射关系的数据 一对一的 键值对

  • ​ 集合类型 : 容器 具有排重的作用 —> 里面的数据不能重复的

13.1 数值类型
整型
	类型名字 int
	这种类型的数据 全部都是整数

	python2.x int这个类型 数据占用的字节数是4B
			  long 长整型  占用的字节数是8B
	python3.x中去掉了long  只保留了int  int占用的字节数与原本的long一致的 8B

浮点型
	float
	这种类型的数据全部是小数

复数型[很少使用]
	complex
	复数有实部和虚部之分  数据格式是  实部+虚部j
13.2 布尔类型
bool

什么情况下使用该类型的数据?
	用于标记某种状态的时候 这种状态只有两种情况

bool的值只有两个 True / False
13.3 字符串类型
str
是一个字符序列 --- 包含字符的一个容器
使用引号来包含单个或者多个字符
字符串的内容一旦确定是不允许更改的  字符串中每个字符也有自己的编号 可以通过编号获取该位置对应的字符

获取格式:
	接受字符串的变量名[索引]
13.4 列表类型[使用比较多]
list
容器, 可以存放多个变量的值, 表示是使用中括号[]来表示的, 也就是在中括号中存放多个数据, 每个数据之间使用逗号隔开. 有序的序列[存放顺序和显示顺序是一致的]
存放在列表中的数据都有自己的编号 这个编号是从0开始的 编号还称之为索引 下标 脚标
可以通过编号来查找数据或者这个这个位置的数据
------------------------------------------------------------------------------
a.可以添加数据
	接受列表的变量名.append(数据)  #在最后添加的
b.在指定位置插入
	接受列表的变量名.insert(索引位置, 数据)
c.移除元素
	1.删除指定数据
		接受列表的变量名.remove(数据)
			删除是第一次出现的数据
	2.删除末尾元素
		接受列表的变量名.pop()
	3.删除指定位置的元素
		接受列表的变量名.pop(索引)
d.获取容器的长度
	len(接受容器的变量名)

#Python是一个动态语言 - 变量的类型是根据赋予的值来决定的
a = 10
#查看变量对应的类型的方式
#1. type(变量名)
print(type(a))

#2. isinstance(变量名, 类型名字) 查看该变量是否是指定类型
print(isinstance(a, int)) #True
print(isinstance(a, float)) #False

a = 10.2
print(type(a))

#字符串类型
a = "hello"
print(type(a))
#根据索引获取指定位置的字符
ch = a[0]
print(ch)

'''
a[0] = "m"
TypeError: 'str' object does not support item assignment
字符串内容一旦确定 不允许后期发生修改
'''
#a[0] = "m"
#print(a)


#列表
l1 = [12, 3.14, True, "hello"]
print(l1)

value = l1[1]
print(value)

l1[1] = 3.1415926
print(l1)

l1.append(99)
print(l1)

#获取长度
length = len(l1)
print(length)

#在指定位置插入
l1.insert(0, "头儿")
print(l1)
#末尾追加
l1.append(12)
print(l1)

#删除
l1.remove(12) #删除第一次出现的元素
print(l1)
#删除末尾元素
l1.pop()
print(l1)
#删除指定位置
l1.pop(2)
print(l1)
13.5 元组类型
tuple
每设置一个数据 都在内存中有其独立的地址
获取数据对应的地址  id（变量）
容器，用于存放多个变量的数据，长度一旦确定是不允许发生变化的，而且元组中元素的数据地址不允许发生变化
在元组中添加的元素也有对应的编号，可以通过编号获取元素的值

元组声明的时候   使用小括号（）来包含元素的
注意：
 （）具有提高优先级的意义
 如果声明元组时 元素只有1个 需要在该元素的后面添加逗号分隔   告诉Python解释器这个小括号是元组数据的代表   而非是提高优先级的意义。如果不加这个逗号的话  解释器会将其解释成提高

**注意：**Python这门语言对于格式对其很讲究 平级的语句不允许出现缩进的情况 左边必须是平齐的

m = 32
print(id(m))

m = 12
print(id(m))

tuple0 = (23, 56, 78, True)
print(type(tuple0))
print(tuple0)

value = tuple0[0]
print(value)

'''
: 'tuple' object does not support item assignment
'''
#元组中数据的地址不能发生改变  不能被再次赋值
# tuple0[1] = 77
# print(tuple0)
# 注释的快捷键 ctrl + /   解开注释 再使用ctrl + /

#如果只有一个元素的时候 必须在该元素后添加逗号 才会将该数据解释成元组
#否则 小阔号就是一个提高优先级的含义 会将小括号中的数据赋值给变量名
tuple1 = (10,)
print(tuple1)
print(type(tuple1))
13.6 集合类型
set
容器  没有索引一说   主要作用用于排重（排除重复）
无序的---添加顺序和最终的顺序可能不一致 但是数据位置一旦确定 不管再怎么运行  位置都不会发生变化

set（容器）------>集合类型

#集合
list1=[77, 28, 31, 52, 44, 28, 77, 66, 28]
set0 = set(list1)
print(set0)
>>>{
    
    66, 44, 77, 52, 28, 31}
13.7 字典类型[使用比较多]**
dict
存放的是具有映射关系的键值对  键值对的格式：key：valus 是使用{}来包含多个键值对的，每个键值对之间使用逗号隔开
{key：valus，key1：valus1，key2：valus2}

字典没有索引一说，是通过键查找值得，要求：键不允许重复 而且一般键的地址是不允许发生变化的  键使用的是不可变得数据类型（常用的就是整型，字符串类型）

通过键来查找值得方式：
	接受字典的变量名[键名]
		这种方式如果键不存在  会报错 会报错keyError 程序会终止 

或者

	接受字典的变量名.get（键名）
 	如果键不存在  不会报错  返回一盒个特殊值None

在字典中新增键值对
		接受字典的变量名[键名]=值
     	如果键名已经存在   将新值覆盖旧值
     	不存在会当做一个新的键值对添加
移除键值对
	方式1：
		接受字典的变量名.pop（键名）
	方式2：
 	del 接受字典的变量名[键名]

#字典
dict0 = {
    
    "英语":88, "数学":99}
print(dict0)

#没有索引一说
#KeyError: 0  键错误 --  表示的字典中没有0这个键
# item = dict0[0]
# print(item)

#通过键来查找值的方式
# value = dict0["英语1"]
# print(value)

value = dict0.get("英语1")
print(value)

print(len(dict0))


print(dict0)
dict0["语文"] = 65
print(dict0)

dict0["英语"] = 65
print(dict0)

# dict0.pop("数学")
# print(dict0)

# del dict0["数学"]
# print(dict0)

14. 输入功能

输出功能:
	print(数据) -- 结果显示在控制台上
输入功能:
	结果 = input(提示语:提示用户输入什么数据)
	结果接受的就是用户输入的数据

	注意 python2.x和python3.x的区别
	在python2.x的版本中 输入什么格式的数据  结果就是该数据对应的类型
	在Python3.x的版本中 不管输入的是什么格式的数据 结果都是字符串类型的

15. 不同的类型之间的转换

1.将数据转化为整型
	一般使用会将字符串  /  小数转化为整型
	转化的方式  int（数据）

	注意：转换字符串
		字符串可以以+或者-开头
		其余的必须是整数数字格式的  不允许包含其他数字内容 如果包含的话就会转换失败    报错

#类型转换

x = 3.14
print(x)

res = int(x)
print(res)

s = "+99."
res = int(s)
print(res)
print(type(res))

2.转化为浮点型
	将数值 / 字符串进行转换
	float(数据)
	注意:
		字符串 可以包含正确的正负符号
		可以包含一个小数点.  
		必须满足的小数/整数的数据格式 否则的话将会转换失败 报错
res = float(3)
print(res)

res = float("9..9")
print(res)

3.转化为bool类型
	值只有True / False

	数值类型:  非0即为True
	字符串类型: 非空字符序列即为True  空字符序列:只有一个引号 引号中没有任何内容""
	其他类型: 非None即为True

	bool(数据)

4.将数据转化为字符串类型
	str(数据)

5.解析字符串
	eval(字符串)
		可以将字符串中式子提取进行对应的运算
		也可以提取字符串中对应的数据 结果类型为字符串中数据的类型
		eval的使用
		解析字符串 扒掉外层字符串的衣服 剩下的是什么 就是什么
	"a" -----> 字符串数据
	a -----> 起的变量名 如果使用它的话是使用该变量对应的数据的

	eval("a") =====> a  #注意 如果前面没有声明过a这个变量 使用的话报错/////
 code="12+34"
res=eval(code)#拔掉字符串这层衣服
print(res)#输出为int型46

con="10"
res=eval(con)
print(res)#输出 int型10

con1="[12,34,56]"
res=eval(con1)
print(res)#输出list型[12,34,56]

con2="(12,34,56)"
res=eval(con2)
print(res)#输出tuple型（12,34,56）


6. 编码
	将生活中常用的数据与计算机数据关联
	关联的中间介质是十进制数据
	生活中的数据 <-----> 十进制 <------>二进制
获取生活中某个字符对应的十进制数据  ord(单个符号)
	"a" ====> 97
	"A" ====> 65
	"0" =====> 48

	你 ====> 
根据十进制数据获取其对应生活中的字符  chr(十进制数据)
	#要求十进制数据的范围:
		0-0x110000 ====> 十进制范围 [0, 1114112)


7.进制之间的转换
	将数据转化为16进制
		hex(数据)
	转化为二进制
		bin(数据)
	转化为八进制
		oct(数据)

16. 运算符

16.1 算术运算符
基本算术运算符:

	+
		在数值类型中将两个数进行求和
		在字符串类型中 将两个字符串进行拼接 生成一个新的字符串
-------------------------------------------------------------------------------		
	-
		数值中 求差
-------------------------------------------------------------------------------           *
		在数值类型中 求积
		在字符串类型中 将字符串原有内容重复n遍 生成一个新的字符串
-------------------------------------------------------------------------------       
	/
		数值中做商 保留小数
-------------------------------------------------------------------------------       
	//
		数值中做商  结果只保留整数
-------------------------------------------------------------------------------
	%   
		取模 做商之后取的是余数
		一个数a能被另一个数b整除 === 做商之后没有多余的数剩下 
		 a % b == 0
-------------------------------------------------------------------------------       
	**
		幂数
		 x ** y ===> x的y次方
-------------------------------------------------------------------------------     
复合赋值运算符
	=
	+=
		a += b =====> a = a + b
	-=
		a-=b ====> a = a - b
	*=
		a *= b ====> a = a * b
	/=
	 	a /= b ====> a = a / b
	//=
		a //= b ====> a = a // b
	%=
		a %= b ====> a = a % b
	**=
		a **= b ====> a = a **b 

a = 10
b = 20
'''
等号左边的变量 是等待被赋值的
等号右边的变量 是取变量的值的 这个时候相当于使用变量 如果之前没有声明并赋予初始值 就会报错
'''
res = a + b
print(res)

s1 = "abc"
s2 = "-def"
res = s1 + s2
print(res, s1, s2, sep="     ")

res = a * b
print(res)

res = s1 * 2
print(res, s1, sep="        ")

x = 11
y = 2
print(x / y)
print(x // y)
print(x % y)

print(x ** y)

m = 10
n = 5

m **= n
print(m)
16.2 关系运算符
经过关系运算符运算之后 最终的结果是bool类型的

> 大于
< 小于
>= 大于等于
<= 小于等于
== 是否相等
!= 是否不相等

在数值中比较数值的大小 或者是否相等
在字符串中 比较方式
	从第一个字符开始两者一一去对应比较的  本质上比较的是该字符对应的十进制数据
	其中某个字符比较出来大小 比较结束 

a = 10
b = 20
print(a > b)
print(a < b)
print(a >= b)
print(a <= b)
print(a == b)
print(a != b)
print("------------------------------")
s1 = "abcd"
s2 = "ab"
print(s1 > s2)
print(s1 < s2)
print(s1 >= s2)
print(s1 <= s2)
print(s1 == s2)
print(s1 != s2)
16.3 逻辑运算符
运算符两边绑定的数据是bool类型的  运算之后的结果也是bool类型的
逻辑与(and)
	规则: 一假则全假 ===> and符号两边有一方为假False  结果就是False
逻辑或(or)
	规则: 一真则全真 ====> or符号两边有一方为True 结果就是True
逻辑非(not)
	规则: 真变假 假变真 ===> not后面的结果是True 最终结果为False
						 not后面的结果是False 最终结果为True

优先等级: not > and > or
短路原则:
	逻辑与and的短路原则:
		根据一假则全假出现的
		如果and左边的表达式不成立False 右边表达式不会被执行  如果后面有or的表达式 会直接执行or后面的内容

	逻辑或or的短路原则:	
		如果or左边的表达式成立True 右边表达式不会被执行 

	 根据这个规则出现一个语法:  三元运算符  值1和值2遵守的bool转换原则  这个三元运算符有弊端
		 	变量名 = 条件表达式 and 值1 or 值2
		 	条件表达式成立 执行值1
		 	否则执行 值2
		 演示求两个数的最大值

	以后使用三元运算符:
		变量名 = 值1 if 条件表达式 else 值2	

x = 0
y = -1

res = x > y and x or y
print(res)

res = x if x > y else y
print(res)
16.4 成员运算符
针对于容器而言的
判断指定元素是否在指定的容器中
in    在的话为True

判断指定元素是否不在指定的容器中
not in  不在为True

s = "abcdef"
list0 = ["a", "b", "c", "d"]

res = "ba" not in s  #不仅判断是否有这个字符 还判断顺序是否正确
print(res)

res = "a" in list0
print(res)
16.5 身份运算符
验证变量的地址是否一致

is -- 地址一致结果为True
is not --- 地址不一致结果为True


id(数据) 获取数据的地址
16.6 位运算符

位运算符

针对于二进制数据的运算
二进制数据运算时是以补码的形态运算的
规则:
	把1视作True  0视作False
二进制数通过运算符运算的时候 符号位也要参与运算的

以八位为例

按位与(&)
	两个二进制数 上下一一对应参与运算
	运算准则: 一假则全假

	5&-7
		5的补码: 0000 0101
		-7的原码: 1000 0111
		-7的反码: 1111 1000
		-7的补码: 1111 1001
		  &		 0000 0101
		  ------------------
		  		 0000 0001 -----> 1
按位或(|)
	两个二进制数 上下一一对应参与运算
	运算准则:一真则全真

	5 | (-7)
		0000 0101
	|	1111 1001
	----------------
		1111 1101 [补码] ----> -1求反码: 1111 1100 ----> 取反求原码: 1000 0011 [-3]
按位异或(^)
	两个二进制数 上下一一对应参与运算
	运算准则: 相同为假 不同为真

	5 ^ -7
		0000 0101
	^	1111 1001
	--------------
	     1111 1100[补码] ---> -1求反码:  1111 1011 ----> 取反求原码: 1000 0100 [-4]

	小知识点:
		一个数与相同的数异或两次 结果是其本身 ----> 简单的小小的加密
			密码: 123456 ----> 对应与一个数异或: 765489
			用户输入123456 ---->验证的时候 异或一个对应的数据 与 存放的数据进行验证匹配
		交换两个变量的值
			a = 10
			b = 20
			 ====> a = 20  b = 10
按位取反(~)
	0变1  1变0

		~(-7)
			1111 1001
		~
     -----------------
     	 0000 0110 ----> 6
按位左移(<<)
	将二进制数向左移动指定的位数 右边会空出 空出补0

		1 << 3 ===> 1左移3位

		0000 0001

		结论:
			原有的数据 * 2 ^ 移动的位数

按位右移(>>)
	将二进制数向右移动指定的位数 左边会空出 正数补0   负数补1

		32 >> 2 ====> 8

		结论: 原有的数据 // 2 ^ 移动的位数
res= 5 & (-7)
print(res)

res= 5 | (-7)
print(res)

res= 5 ^ (-7)
print(res)

res = -4 ^ -7  # 5 ^ -7 ^ -7
print(res)


a, b = 10, 20
# a, b = b, a
# print(a, b)

#因为当为a重新赋值的时候 a原来的值没有变量名接受了 所以这个数据就无法获取了  消失了
#先把a原来的值 使用另外一个变量名接受
# c = a
# a = b
# b = c
# print(a, b)


a = a ^ b
b = a ^ b # b = a ^ b ^ b = a
a = a ^ b # a = a ^ b ^ a = b
print(a, b)


res = ~-7
print(res)

res = 1 << 3
print(res)

res = 32 >> 2
print(res)
16.7 转义符
\ --- 具有转移的含义
可以使用其后面的字符失去原本意义  生成一个新的含义
\n -- 换行
\t --- 制表符 tab
\r --- 回车

windows中表示换行的是 \r\n
如果以后写代码的时候 \n没有达到换行的效果 使用\r\n

17. 知识点–判断语句

三种:
	if单语句:
		if 条件表达式:
			[缩进tab]执行语句 --- 为什么要缩进?  执行语句是在满足if判断条件的情况下执行的
	if-else
		if 条件表达式:
			执行语句1
		else:
			执行语句2
		如果条件表达式成立 执行语句1  否则执行语句2

'''
键盘录入一个字符  如果是小写英文字母 将其转化为大写英文字母
否则 输入字符原本样子
'''
ch = input("请输入一个字符:")

#方式1
# if 'a' <= ch <= "z":
#     print(chr(ord(ch) - 32))
# else:
#     print(ch)
#
# print("over")


#方式2:
data = ord(ch)
if 97 <= data <= 122:
 print(chr(data-32))
else:
 print(ch)

17. 位运算符补充

位运算符	

交换两个变量的值:[重点]
	第一种方式: Python独有的:
		a , b = 10, 20
		a, b = b, a  #等号左边的变量 是等待被赋值的  右边的变量是取原来对应的数据的
	第二种方式: 借助第三方变量 [JavaScript]  一般情况下应用于非Python的两个变量的交换
		c = a
		a = b
		b = c
	第三种方式: 使用异或的 一个数与相同的数异或两次 结果是其本身 [了解]
		先将两个数进行异或
		a = a ^ b
		b = a ^ b # b = a ^ b ^ b = a
		a = a ^ b # a = a ^ b ^ a = b

18. 模块与range功能的使用

模块 -----> 一个py文件就是一个模块 可以把模块当做一个工具箱使用

​ 模块之间是可以互相访问的 访问的前提需要导入要使用的模块

​ 自己定义的模块之间的访问

​ 使用系统提供的模块 random 随机模块

​ range — 可以生成一个整数序列的功能

一个python文件就是一个模块 把他当做一个工具箱

不同的python文件是可以相互访问的 访问的前提需要导入使用模块

导入模块的格式:

​ import 模块名

​ 使用模块中的内容的话 模块名.内容名

​ from 模块名 import 内容名字 ====> 在指定模块中导入指定内容

​ 使用内容的话 直接使用内容名

​ 这种导入 只能使用该模块下你导入的内容名

​ from 模块名 import * =====> 导入指定模块中所有的内容

​ 可以直接使用该模块下的所有被__all__这个列表包含的内容,如果模块中没有设置__all__这个字段, 默认是使用所有

原生模块 random的使用
	random这个是随机模块 --- 可以在指定的内容中产生随机数据
	import random

#1. 在指定的容器中随机选择一个元素
res = random.choice("abcdefghtyui")
print(res)

res = random.choice((12, 34, 65, 71))
print(res)

#2. 在指定的整数范围内随机选择一个整数
#在指定的闭合区间中 随机的选择一个整数  [0, 1000]
value = random.randint(0, 1000)
print(value)

#3. 在指定的整数范围内随机选择一个整数  前闭后开的区间  [start, end)
value = random.randrange(1, 100, 2)
# ====>
value = random.choice(range(1, 100, 2))


#4.在指定的序列中选择指定个数的随机的功能
res = random.sample("1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM", 5)
print(res) #使用列表容器存放产生的多个随机元素


range的使用
	产生整数序列
		help(功能)
help(range)
'''
range(stop) -> range object
 传入一个结束值  区间的开始值是0
 生成的这个区间序列 [0, stop)
range(start, stop[, step]) -> range object
 需要传入起始值 传入结束值  step表示的是步长 默认是1
 如果传入step 会按照指定步长递增 或者 递减

 生成的区间 [start, stop)
'''

reslut = range(10)
print(reslut)
#将指定序列转化为列表  list(序列) ==> 将序列中的每一个元素存放于列表中
res_list = list(reslut)
print(res_list)


reslut = range(1, 10) #生成一个步长为1的序列  序列的起始值是1
res_list = list(reslut)
print(res_list)


reslut = range(1, 10, 2) #生成一个步长为1的序列  序列的起始值是1
res_list = list(reslut)
print(res_list)

#从10 -1 这种递减  10 9 8 7 6 5 4 3 2 1
reslut = range(10, 0, -2) #生成一个步长为1的序列  序列的起始值是1
res_list = list(reslut)
print(res_list)

#设置外界使用模块内容的权限
__all__ = ["name", "add", "div"]

name = "工具箱"

#设置一个功能  函数的封装  计算两个数的和
'''
一个: 是否有位置项参与功能的运算
 有多少个 在函数名的小括号中写多少个变量名
2. 问一下 这个功能是否需要将结果返回给使用者
    在函数中需要有return 一个返回 将结果返回给使用者
    如果没有 return可以省略 或者 return None ===> 使用者获得的结果是None
函数格式:
    def 功能名字(接受未知项的变量名):
        功能的实现
        return 功能运算结果
'''
def add(a, b):
    total = a + b
    return total

def div(a, b):
    return a / b



  #第一种导入方式
# import tool
#
# res = tool.name
# print(res)
#
# res = tool.add(12, 16)
# print(res)

#第二种导入方式
# from tool import name, add
#
# res = name
# print(res)
#
# #如果没有导入其他模块的内容  在当前模块中查找
# res = add(12, 34)


#第三种导入方式
from tool import *

res = name
print(res)

res = add(12, 45)
print(res)

res = div(12, 3)
print(res)


练习:
	1.使用range生成以下序列
		-1 ~ -10	
		range(-1, -11, -1)
	2.生成1-1000的序列  在该序列中随机选择3个数据
		import random
		res_list = random.sample( range(1, 1001) , 3)

19. 流程控制语句

19.1 顺序语句

什么叫做语句??

​ 在语法上自成体系的一个单位, 可能是一个词, 也可以能是通过逻辑关联的多个词

​ a:int

​ a = 10

在一般的编程语言中 语句结束的标志是分号(😉

在Python中语句结束的时候也可以以分号结尾 允许不写[建议不写]

​ 什么情况下来写?? ----- 如果在一行中书写多条语句, 这个分号就不能省略了

建议 最好是一条语句占用一行

顺序语句的意思: 表示的是代码的执行顺序 是从上往下走的

print("hello")

print("h");
print("b")
19.2 分支语句

分许需求的时候出现了不同的情况 — 出现了分支

出现了不同的情况 – 有可能会出现 —> 如果出现了 —> if

分支语句是if语句

if单语句 ---- 是一个整体
	if 条件表达式:
		[缩进tab]执行语句
	执行的流程:
 	判断条件表达式是否成立  成立的话  执行语句 if语句整体执行完毕 结束  向下执行与if平级的语句
 	不成立的话  if语句直接执行完毕 向下执行与if平级的语句
 案例:
 	键盘录入一个整数 判断这个数是不是偶数
 	偶数的概念: 能被2整除 ---> 余数为0   num % 2 == 0 

if-else语句
	if 条件表达式:
		执行语句1
	else:
		执行语句2
	执行流程解读:
		先判断条件表达式是否成立  如果成立的话 执行语句1 if-else整体结束
		否则 执行语句2  if-else语句结束

	案例:用户输入一个年份 验证这个年份是否是闰年
		闰年的条件判断:
			1.能被4整除 但是不能被100整除 year % 4 == 0 and year % 100 != 0
			2.能被400整除  year % 400 == 0
			1和2之间的关系 是满足其一即可  or
year = int(input("请输入一个年份:"))

if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
 print(year, "是闰年")
else:
 print(year, "不是闰年")


print("验证完毕")

import random			


	练习:
		在1-100中随机生成两个数
			前者>后者  计算两个数的差
			否则计算两个数的和
import random

num1 = random.randint(1, 100)
num2 = random.randint(1, 100)
print(num1, num2)
if num1 > num2:
 c = num1 - num2
 print(c)
else:
 b = num1 + num2
 print(b)
print("结束") 



res = random.sample(range(1, 101), 2)
a, b = res
print(type(res))
if a > b:
 print(a-b)
else:
 print(a + b)

x = random.choice(range(1, 101))
y = random.choice(range(1, 101))

if x > y:
 print(x - y)
else:
 print(x + y)

x = random.randrange(1, 101)
y = random.randrange(1, 101)
if x > y:
 print(x - y)
else:
 print(x + y)

if-elif-else语句  elif ===> else if的简写
	注意: 只有 if如果的后面才会有条件表达式的判断 else是没有条件判断的 只有一个:跟随其后

	if 条件表达式1:
		执行语句1
	elif 条件表达式2:
		执行语句2
	....
	elif 条件表达式n:
		执行语句n
	else:
		上述列出的所有条件表达式都不满足 才会执行else

	这多个if并联的是一条语句 满足其中一个条件 整体结束

	案例:
		猜字游戏 猜一次
		系统随机生成一个50-300的整数 sys_num
		用户输入一个50-300的整数  user_num
		两个 比较大小
			如果 用户 大于 系统
				提示用户猜大了
			否则如果 用户 < 系统
				提示用户猜小了
			否则
				提示用户中奖了
import random

sys_num = random.randint(50, 300)
print(sys_num)
user_num = int(input("请输入一个50-300的整数:"))

#进行判定
if user_num > sys_num:
 print("猜大了")
elif user_num < sys_num:
 print("猜小了")
else:
 print("中奖了")

print("游戏结束")			



	练习:
		1.用户输入一个季节 根据季节输出对应的描述
			春 ---- 万物复苏
			夏 ---- 烈日炎炎
			秋 ---- 硕果累累
			冬 ----- 白雪皑皑

season = input("请输入一个季节:")
if season == "春":
 print("万物复苏")
elif season == "夏":
 print("烈日炎炎")
elif season == "秋":
 print("硕果累累")
elif season == "冬":
 print("白雪皑皑")
else:
 print("输入正确的季节")            

		2.成绩等级划分
			录入学生成绩 输出对应的等级
				>= 90	A
				>= 80	B
				>= 70	C
				>= 60	D
				其他	  E
grade=int(input("请输入学生的成绩："))
if grade>=90:
 print("A")
elif grade>=80:
 print("B")
elif grade>=70:
 print("C")
elif grade>=60:
 print("D")
else:
 print("E")
print("请继续努力")               

		3.用户输入字符
			如果是小写英文字母 --- 输出其对应的大写字母
			如果是大写英文字母 ---- 输出其对应的小写字母
			其他 输出字符本身
ch = input('请输入一个字符:')
res1 = ord(ch) #获得字符对应的十进制数据
if 65 <= res1 <= 90:
 print(chr(res1 + 32))
elif 97 <= res1 <= 122:
 print(chr(res1 - 32
最低0.47元/天 解锁文章

200万优质内容无限畅学
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值