python学习笔记（持续更新）

基本格式

在python中严格区分大小写
每行就是一个语句 以换行为结束
每一条语句不要太长，建议不超过80字符
一条语句如果太长可以用\换行继续编辑
python是缩进严格的语言 不要随便写缩进（空格）
python中用#代表注释，对程序进行解释说明，#后的内容会被解释器忽略

字面量和变量

-字面量 1 2 3 hah  hello
-变量  可以用来保存字面量 a=10  print (a)
变量本身没有意思，根据不同的字面量表示不同的意思

变量和标识符

变量
 -python中使用变量不用声明，直接赋值即可
 -我们不能使用没有赋值的变量 报错（nameerror：name 'x' is not defined）
 -python 是一个动态类型的语言，可以赋任意类型的值（a=1 a=hello a=1.5）
标识符
 -在python中可以自主命名的内容都属于标识符
 -例如：变量名 函数名  类名
 -标识符规范：可以含有 字母 数字 下划线，但是不能使用数字开头（1asdas）
 -命名规则 
       1下划线命名法（全字母小写，单词之间_链接）max_length, hello_world
       2帕斯卡命名法（首字母大写，其余字母小写）Maxlength
 -如果不按照规范命名，报错信息：syntaxerror：invalid syntax

数据类型

数据类型就是变量的值的类型
python中的数值分为三种：整数 浮点数 复数
-整数
 python中的所有的整数都是int类型的 
 整数的大小没有限制
 如果数值较大可以用_进行划分  123_456_789=123456789
 10进制的数字不能以0开头，如果数字打印，一定是10进制显示的
-浮点数
 浮点数进行计算的时候可能得到一个不精确的结果 0.1+0.2=0.3000000000000000004（因为二进制无法精确表示1/10）

字符串

字符串表示一段文本信息，是程序中使用最多的数据类型
字符串需要用引号引起来 s= 'hello'
相同的引号之间不能嵌套

长字符串
s='锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦'
用三重'''保留文本格式，也可以使用\n强制换行。
s='''锄禾日当午，
 汗滴禾下土，
 谁知盘中餐，
 粒粒皆辛苦'''

print (s)

转义字符
  \'表示'
  \"表示"
  \t 表示制表符
  \n表示换行符
  \uxxxx 使用union编码   \u0040  打印编码

格式化字符串
a='hello' 
print(a)           打印hello


a='asd'+'hahah'+'123'
print("a="+a)     打印a=assdhahah123       (不推荐)


a='asd'+'hahah'+'123'
print('a=',a)


b='hello %s'%'world'      
print(b)         打印 hello world

b='hello %s hello %s'%('tom','world')
print(b)             打印 hello tom hello world

b='hello %.2f'%123.456      
print(b)         打印 hello 123.46

b='hello %d'%123.456      
print(b)         打印 hello 123

（%s字符串的占位符，用%后面的字符填充占位符）
（%f浮点数的占位符，用%后面的小数填充占位符）
（%d整数的占位符，用%后面的整数填充占位符）
格式化字符串中可以在字符串前加一个f来创建一个格式化的字符串，也可以在字符串中嵌入变量

a=123
b=‘hah’
c=f’hello{a}{b}’
print(f’c={c}’) 打印c=hello123hah

布尔值

主要用来做逻辑判断，一共有俩 true false
a = True
a = False
布尔值也属于整型，True相当1，Flase相当于0
-print(1+True) 打印2
-print(1+Flase) 打印1

None(空值)

用来表示空值，不存在
b = None
print(b) 打印None

类型检查

检查指定值的类型 type() 函数
该函数会将检查结果作为返回值返回，通过变量接受返回值
a = 123
b = ‘123’

print(‘a=’,a)
print(‘b=’,b) 但是输出ab都是123

c = type(a)
print© 输出<class ‘int’>

c = type(‘123’)
print© 输出<class ‘str’>

对象（object）

-python是面向对象的语言
-一切皆是对象
-程序运行中，所有的数据都存在内存中再运行.
-对象就是内存中专门用来存储指定数据的一块区域
-对象实际上就是一个容器

对象结构

-每个对象都有三种数据
    ·id     唯一标识
        >>id是由解析器生成的
        >>就是对象的内存地址
    ·type   对象类型
        >>表示当前对象所属的类型(int str float bool )
        >>类型决定了对象有哪些功能
        >>python是强类型语言，对象一旦创建，类型无法改变
    ·value  对象的值
        >>值就是对象中存贮的具体的数据
        >>由于可变对象，值是可以改变的（可变对象，不可变对象）

变量和对象

-对象并没有存储再变量中，python中变量更像是对象的一个别名。
-变量中存贮的不是对象的值，而是对象的id.通过对象的id查找对象。
-变量中保存的，只有在为变量重新赋值的时候才会改变。
-变量与变量之间是相互独立的。

类型转换

 -将一个类型的对象转换为其他对象
 -不是改变对象本身的类型，而是根据当前对象的值创建一个新的对象
 -类型转换的四个函数
   ·int()
      >> 用来将其他的对象转换为整型
      >>布尔型 true -> 1 false -> 0 
      >>浮点数 直接取整 省略小数点后的数字
      >>字符串 合法的整数字符串，转换为对应的数字，非法的报错
  ·float()
      >>和int()基本一致，不同的就是会将对象转换为浮点数
  ·str()
      >>将对象转换为字符串
  ·bool()
      >>存在的就是True，空就是flase(0,none,''...)

例如：
a=123
a=float(a)

print(‘a=’,a)
print(‘a的类型是’,type(a))

打印：
a= 123.0
a的类型是 <class ‘float’>

运算符（操作符）

-运算符可以对一个或者多个值进行各种操作
-运算符分类：
  ·算数运算符
     >>%（取模） + - * /  // **(幂)(// 整除，总会返回整数）
  ·赋值运算符
     >>等号右侧的值赋值给等号左边的变量  a = 10
  ·比较运算符（关系运算符）
     >>    >  <  >=  <=  ==  !=
     >>用来比较两个值之间的关系，总会返回一个布尔值
     >>python中可以对两个字符串进行比较，实际上比较的是字符串的union编码
     >>相等和不等，比较的是对象的值，而不是id
  ·逻辑运算符
     >>主要做一些逻辑判断
      >>可以连着使用
       ·1<2<3
       ·先当于1<2 and 2<3
       ·对中间的数比较
     >>not逻辑非
       ·一元运算符，可以对符号右侧的值进行非计算
       ·对于非布尔值，not会先将其转换为布尔值，再取反
     >>and逻辑与
       ·二元运算符，对左右两侧的值进行与运算
       ·全真则真
     >>or逻辑或
       ·二元运算符，对左右两侧的值进行或 运算
       ·有真则真
  ·条件运算符

result = 10 > 20
print(‘result=’,result)

result = ‘2’ > ‘1’ true
result = ‘2’ > ‘11’ true

print(‘result=’,result)

非布尔值的与或运算

 -当对非布尔值进行与或运算的时候，python会将其当作布尔值进行计算，返回原值
与运算
 -如果第一个值是false,则返回第一个，否则返回第二个。
或运算
 -如果第一个值是true,则返回第一个，否则返回第二个。

条件运算符 （返回布尔值）

语法：语句1 if 条件表达式 else 语句2
执行流程：条件运算符执行时，会先对条件表达式进行求值判断
-判断结果为真，执行语句1，返回结果
-判断结果为假，执行语句2，返回结果

运算符优先级

-和数学中一样，运算符也有优先级。先乘除后加减。
-or和and，and优先级比较高。
-官方手册优先级表格中越往下，优先级越高。
-如果不清楚，可以使用（）改变优先级。

流程控制语句

-python代码执行时是按照自上向下的顺序执行的
-通过流程控制语句，可以改变程序执行的顺序，也可以让指定的程序反复执行。
-语法：if 条件表达式 ：语句
-执行流程：if语句在执行的时候，会先对条件表达式进行求值判断，如果为真，就执行if后的语句，如果为假就不执行。
-默认情况下if只能控制紧随其后的那条语句。如果下网if控制多条语句，可以后跟代码块。（保存着一组代码，要么都执行要么多不执行）
-代码块以缩进开始，跳出缩进就结束。
-缩进有两种方式  1：tab键  2 ：4个空格，但是缩进方式要统一。

a = 10
if a > 8 :
print(123)
print(456)
print(789)
print(‘不受控制’)

-可以用逻辑运算符来链接多个条件
-同时满足用and 有一个满足即可，用or。

num = 18
if num > 10 and num < 20 :
print(‘num比10大比20小’)

input函数

-用来获取用户输入
-调用input函数后，程序会立即暂停，等待用户输入
-用户输入内容以后，回车键继续执行程序
-input（）的返回值是一个字符串
-input（）函数中可以设置一个字符串为提示文字，会显示在程序运行中提示用户输入
-input（）可以暂停程序，阻止程序结束

usernam = input(‘请输入用户名：’)
if usernam == ‘admin’ :
print(‘欢迎’,usernam,‘登录’)
else :
print(‘欢迎’,username,‘光临’)

print(hahah)
input(点击回车键关闭。。。)

if-else语句

-先对if-else后的表达式进行求值判断
-true就执行if后的代码块
-false就执行else后的代码块

age = input(‘请输入您的年龄’)
if int(age) >= 18 :
print(‘您已经成年了’)
else :
print(‘您还未成年~’)

if-elif-elif-else语句

-语法：
if  条件表达式：
	代码块
elif 条件表达式：
	代码块
elif 条件表达式：
	代码块
else :
	代码块

-执行流程：
 自上向下依次对条件表达式求值判断，
 如果表达式为True,则执行当前代码块，然后语句结束
 如果表达式为False,则继续向下判断，直到找到True为止
 如果都为false,则执行else后的代码块
 （这种语句只会有一个代码块执行）

age = int(input（请输入你的年龄))

if age >= 100 :
print(‘活着好累啊！’)
elif age >= 80 :
print(‘老大不小了！’)
elif age >= 60 :
print(‘终于退休了！’)
elif age >= 18 :
print(‘你已经成年了！’)
else ：
print(‘你还小着呢！’)

5道题练习题

练习 1 小明的成绩跟奖励
chengji = int(input(‘你考了多少分啊？0-100之间’))
if chengji == 100 :
print(‘奖励一辆宝马’)
elif chengji >=80 and chengji <= 99:
print(‘奖励一台手机’)
elif chengji >=60 and chengji <=79 :
print(‘奖励一本书’)
else :
print(‘该挨打了，你真考了’,chengji,’???’)

练习 2 判断数值的奇偶性
a = int(input(‘请输入整数’))
if a%2 == 0 :
print(‘这是个偶数！’)
else:
print(‘这是个奇数！’)

练习 3 判断年份是不是闰年
nianfen = int(input(‘输入年份’))

if nianfen%400 == 0 or nianfen % 4 == 0 and nianfen % 100 != 0 :
print(nianfen,‘是闰年~’)
else:
print(nianfen,‘不是闰年’)

练习 4 狗狗相当于人类的年龄
gougou = int(input(‘狗狗的年龄’))
if gougou <= 2 and gougou > 0 :
print(‘狗狗相当于人的年龄’,gougou*10.5)
elif gougou >= 2 :
print(‘狗狗相当于人的年龄’,21+(gougou-2)*4)
else :
print(‘请输入正数’)

练习 5 择偶
shenhao = int(input(‘请输入您的身高,单位cm----’))
jiachan = int(input(‘请输入您的家产,单位万元----’))
yanzhi = int(input(‘颜值打分，请输入0-800，500以上为帅----’))
if shenhao > 180 and jiachan > 1000 and yanzhi > 500:
print(‘我一定要嫁给他’)
elif shenhao > 180 :
print(‘嫁吧，还行’)
elif jiachan > 1000 :
print(‘嫁吧，还行’)
elif yanzhi >500 :
print(‘嫁吧，还行’)
else :
print(‘不嫁！’)

循环语句

-循环语句可以使指定代码块重复指定的次数。
-循环语句条件表达式恒为真的时候，成为死循环，一直运行。
-循环三个要件：初始化表达式，条件表达式，更新表达式。
-循环语句分两种
  ·while循环
     >>语法：
      while  条件表达式  ：
         代码块
     >> 执行流程：
      while语句在执行时，会先对while语句的条件表达式进行求值判断，
      如果条件为真，则执行循环体（代码块），
      循环体执行完毕，继续对表达式进行求值判断，以此类推
      直到判断结果为false，则循环结束
  ·for循环。

循环嵌套

循环嵌套时，外层循环执行一次，内层循环执行一圈
外层循环控制高度，内层控制宽度

判断输入的数是不是质数
num = int(input(‘输入’))
i = 2
flag = True
while i < num:
if num % i == 0:
flag = False
i += 1
if flag:
print(num,‘质数’)
else:
print(num,‘不是质数’)

break continue

break可以用来立即退出循环语句（包括else）
continue 可以用来跳过当次循环，进入下一次循环，不对else影响
pass 是用来判断或循环语句中占位的

i = 0
while i < 5:
i += 1
if i == 3:
# continue
break
print(i)
else :
print(‘循环结束’)

程序优化

-模块，通过模块对Python进行扩展
-引入time模块，来计算程序运行的时间
-time()函数可以用来获取当前时间，返回时间单位是秒

打印100以内所有的质数

第一次优化：break 一旦找到一个数可以被整除，就跳出循环
第二次优化：一个数的平方根以内的数，才有可能找到因子 j <= i ** 0.5
from time import *
begin = time()
i = 2
while i <= 100000:
Flag = True
j = 2
while j <= i ** 0.5 :
if i % j == 0 :
Flag = False
break
j += 1
if Flag :

pass
i += 1

end = time()
print(end - begin,‘秒’)

列表（list）

- 列表是Python中的一个对象
- 对象（object）就是内存中专门用来存储数据的一块区域
- 之前我们学习的对象，像数值，它只能保存一个单一的数据
- 列表中可以保存多个有序的数据
- 列表是用来存储对象的对象
- 列表的使用：
    1.列表的创建
    2.操作列表中的数据

- 练习：
    - 创建一个列表，在列表中保存你最好的5个朋友的名字
        然后分别通过索引来获取每一个朋友的名字

序列（sequence）

- 序列是Python中最基本的一种数据结构
- 数据结构指计算机中数据存储的方式
- 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）
    并且序列中的数据会按照添加的顺序来分配索引
- 序列的分类：
    可变序列（序列中的元素可以改变）：
        > 列表（list）
    不可变序列（序列中的元素不能改变）：
        > 字符串（str）    
        > 元组（tuple）
    - 刚刚我们所讲所有操作都是序列的通用操作01 02 03 三个文件中的操作

EMS（Employee Manager System 员工管理系统） 练习

- 做命令行版本的员工管理系统
- 功能：
    四个：
        1.查询
            - 显示当前系统当中的所有员工
        2.添加
            - 将员工添加到当前系统中
        3.删除
            - 将员工从系统当中删除
        4.退出
            - 退出系统
- 员工信息要保存到哪里？ 列表，在系统中应该有一个列表，专门用来保存所有员工信息的

print(’-’*20,‘欢迎来到员工管理系统’,’-’*20)
yuangongbiao = [‘小明\t21\t男\t2142’,‘小红\t20\t女\t2141’]

while True:
print(‘请选择你的操作’)
print(‘1 查询员工’)
print(‘2 添加员工’)
print(‘3 删除员工’)
print(‘4 退出系统’)

yonghuxuanze = input('请选择1-4：')
print('-'*62)

if yonghuxuanze == '1':
	# 打印员工表头
	print('编号\t姓名\t年龄\t性别\t住址')
	# 打印员工表
	n = 1
	for yuangong in yuangongbiao:
		print(f'{n}\t{yuangong}')
		n += 1
elif yonghuxuanze == '2':
	# 添加员工信息
		yuangong_name = input('请输入员工姓名')
		yuangong_age = input('请输入员工年龄')
		yuangong_gender = input('请输入员工性别')
		yuangong_address = input('请输入员工地址')

		yuangong =f'{yuangong_name}\t{yuangong_age}\t{yuangong_gender}\t{yuangong_address}'
		

		print('是否确定将以下信息添加到系统中？')
		print('-'*62)
		print('姓名\t年龄\t性别\t住址')
		print(yuangong)
		print('-'*62)

		user_confirm = input('输入y或者yes确认添加')

		if user_confirm == 'y' or user_confirm == 'yes' :
			yuangongbiao.append(yuangong)
			print('操作成功')
		else :
			print('操作失败，请重新操作')


elif yonghuxuanze == '3':
	# 删除员工
	del_num = int(input('请输入需要删除的员工编号：'))

	if 0 < del_num <= len(yuangongbiao):
		del_i = del_num - 1
		print('你将要删除的信息为：')
		print('\t编号\t姓名\t年龄\t性别\t住址')
		print(f'\t{del_num}\t{yuangongbiao[del_i]}')

		user_confirm = input('输入y或者yes确认删除')
		if user_confirm == 'y' or user_confirm == 'yes' :
			yuangongbiao.pop(del_i)
			print('编号为',del_num,'的员工已删除')
		else :
			print('输入有误，请重新操作')
		
elif yonghuxuanze == '4':
	print('感谢使用，再见')
	break

else :
	print('输入有误，请根据需求输入1-4之间的整数')
	print('-'*62)

可变对象

- 每个对象中都保存了三个数据：
    id（标识）
    type（类型）
    value（值）    

- 列表就是一个可变对象
    a = [1,2,3]

- a[0] = 10 （改对象）
    - 这个操作是在通过变量去修改对象的值
    - 这种操作不会改变变量所指向的对象    
    - 当我们去修改对象时，如果有其他变量也指向了该对象，则修改也会在其他的变量中体现

- a = [4,5,6] （改变量）
    - 这个操作是在给变量重新赋值
    - 这种操作会改变变量所指向的对象
    - 为一个变量重新赋值时，不会影响其他的变量

- 一般只有在为变量赋值时才是修改变量，其余的都是修改对象

字典（dict）

- 字典属于一种新的数据结构，称为映射（mapping）
- 字典的作用和列表类似，都是用来存储对象的容器
- 列表存储数据的性能很好，但是查询数据的性能的很差
- 在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素
- 在查询元素时，字典的效率是非常快的
- 在字典中可以保存多个对象，每个对象都会有一个唯一的名字
    这个唯一的名字，我们称其为键（key），通过key可以快速的查询value
    这个对象，我们称其为值（value）
    所以字典，我们也称为叫做键值对（key-value）结构
    每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item）

集合（set）

- 集合和列表非常相似
- 不同点：
    1.集合中只能存储不可变对象
    2.集合中存储的对象是无序（不是按照元素的插入顺序保存）
    3.集合中不能出现重复的元素