Python学习笔记
2-27
在命令行窗口中启动的Python解释器中实现 在Python自带的IDLE中实现
print("Hello world")编码规范
每个import语句只导入一个模块，尽量避免一次导入多个模块
不要在行尾添加分号“：”，也不要用分号将两条命令放在同一行
建议每行不超过80个字符
使用必要的空行可以增加代码的可读性
运算符两侧、函数参数之间、逗号“，”两侧建议使用空格进行分隔
避免在循环中使用+和+=运算符累加字符串
适当使用异常处理结构提高程序容错性
保留字与标识符
概念：保留字是Python语言中已经被赋予特定意义的一些单词，开发程序时，不可以作为变量、函数、类、模块和其他对象的名称来使用。
查看保留字
import keyword
s = keyword.kwlist
print(s)运行结果：
1、字母、数字组成。第一个字符不能是数字 2、不能使用保留字 3、区分大小写 4、_下划线开头的一般有特殊含义,尽量避免
number = 0
print(number)
Number = 1
print(Number)
NUMBER = 2
print(NUMBER)运行:
3-06
单行注释
注释是指在程序代码中添加的标注性的文字
多行注释
在Python中将包含在一对三引号('''......''')或者("""......""")之间,而且不属于任何语句的内容认为是多注释
多行注释:标注某个函数的属性,或者标注某个文档的属性,
放在函数的上边一行或者文档的上面(import的下面),写法:三个双引号
文档编码声明注释:用来声明此文档的编码格式,放在文档的上方
两种写法:# -*- coding:utf-8 -*-
# coding=utf-8编码规范
每个import语句只导入一个模块，尽量避免一次导入多个模块
不要在行尾添加分号“：”，也不要用分号将两条命令放在同一行
建议每行不超过80个字符
使用必要的空行可以增加代码的可读性
运算符两侧、函数参数之间、逗号“，”两侧建议使用空格进行分隔
避免在循环中使用+和+=运算符累加字符串
适当使用异常处理结构提高程序容错性变量
查看数据类型
height = input("请输入您的身高:")
print(type(height))运行
变量的命令规范:
1.变量名一定要符合表示的命令规范
2.变量名不能是保留字
3.慎用0和l
4.选择有意义的单词作为变量名
变量的命令格式:
变量名 = value
注意:定义变量的时候不需要声明变量数据类型
查看变量的数据类型:
内置函数:type(变量) 返回值就是变量的数据类型number = 1024
print(type(number))
nickname = "abc"
print(type(nickname))运行
number = 1024
print(id(number))
number2 = 2048
print(id(number2))
number3 = number4 = 4096
print(id(number3))
print(id(number4))运行
查看变量的内存引用地址:
内置函数:id(变量) 返回值是该变量在内存当中引用地址
常量的命名规范:
大写字母和下划线组成:STUDENT_SUM = value常量
在程序运行过程中，值不能改变的量
基本数据类型
1.整数类型:int
十进制
二进制 1010 = 8*1 + 4*0 + 2*1 + 1*0 = 10
八进制 0o123 = 64*1 + 8*2 + 1*3 = 83
注意:以0O或0o开头
十六进制 0~9,A~F 0xB01E = 14*1 + 16*1 + 0 + 4096*11 = 45086
注意:以0X或0x开头
2.浮点类型:小数 float
e = 2.718
注意:浮点类型计算时有精度问题
3.复数
格式: a+bj(a是实部,b是虚部)3-13
字符串类型
字符串类型:str
1.定义格式:
变量 = '内容'
打印一行
变量 = "内容"
打印一行
变量 = '''内容'''或者三引号
可以通过回车的方式换行,且打印出来与字符串格式相同
2.注意:
字符串首尾符号保持一致
引号可以嵌套使用,被嵌套的字符串定义符也会变为字符串的一部分
三双引号嵌套双引号的时候,不能尾接触s1 = 'Python中也可以使用""定义字符串'
print(s1)
s2 = "'内容'也是字符串"
print(s2)
s3 = """'单引号内容'+"双引号内容" """
print(s3)运行
转义字符
转义字符:
\n:换行
\:续行
\0:空 null
\":"转换成字符串
\':'转换成字符串
\\:\ 转换成字符串
\0dd :八进制数,dd指字符,例如:\012 代表换行
\x0a :十六进制,0a指字符,例如:\x0a代表换行s1 = 'Python中也可以使\0用"内容"定义字符串null '
# s2 = ''
print(s1)
s2 = "'内容'也是\012字符串\""
print(s2)
s3 = "'内容'也是\x0a字符串\""
print(s3)运行
限制转义字符
限制转义字符
最喜爱字符串前面加上R或者r,限制转义字符的功能,而且会把转义字符完成打印出来
快速注释: Ctrl + /布尔类型
布尔类型:Boolean
主要表示:真假
True 或 False (都是保留字)
1 0
布尔类型可以进行计算,但是不推荐
对象的假值:
1.Flase 和None
2.数字当中0,包括整数0,小数0.0,复数虚数0
3.空序列,包括字符串 空列表 空字典
4.自定义对象的实例,该对象的__bool__方法的返回False 或者 __len__返回0print(1 + False)
print(1 + True)运行
a = 1
if a == True:
print("a为True")
else:
print("a为False")运行
3-20
数据类型转换
数据类型转换:
1.int(x):x代指对象,返回值是一个整数类型,对象->整数
x为字符串:字符串应全为整数
x为小数:只保留整数部分
x不能是负数
x为布尔类型:True = 1 False = 0
2.float(x):x呆滞对象,返回值是一个浮点类型的值,对象->浮点类型
x为字符串:字符串应全为整数,除了复数
x为整数:整数,0
x不能是负数
x为布尔类型:True = 1.0 False = 0.0
3.str(x):x代指对象,返回值是一个字符串,对象->字符串
x可以是所有基本数据类型
4.complex(real,[imag]):real代表实数部分,imag代表虚数部分,返回值是一个复数,创建一个复数
5.repr(x):x代指对象,返回值是一个字符串,对象->表达式字符串
x可以是所有基本数据类型
6.eval（x):x代指字符串对象.返回值根据字符串内容定,字符串对象->数字类型
x为整数字符串,返回值为整数类型
x为浮点字符串:返回值为浮点类型
x为复数字符串:返回值为复数
7.chr(x):x代指整数,返回值是一个字符,整数->字符
参照的是ASCII表
48:0
65:A
97:a
8.ord(x):x代指字符,返回值一个整数,字符->整数
9.hex(x):x代指整数,返回值是一个十六进制字符串,整数->字符串
10.oct(x):x代指整数,返回值是一个八进制字符串,整数->字符串
11.bin(x):x代指整数,返回值是一个二进制字符串,整数->字符串
12.round(x[,ndigits]):x代指浮点数,ndigits代指位数,返回值是一个四舍五入的浮点数或整数x = "123"
a = int(x)
print(a)
print(type(a))运行
a = complex(1)
print(a)
print(type(a))运行
a = complex(1,2)
print(a)
print(type(a))运行
x = "1.26165"
# a = complex(1,2)
a = eval（x)
print(a)
print(type(a))运行
x = "3"
a = ord(x)
print(a)
print(type(a))运行
x = 10
a = bin(x)
print(a)
print(type(a))运行
x = 1.1
a = round(x)
print(a)
print(type(a))运行
x = 1.556
a = round(x,1)
print(a)
print(type(a))运行
3-27
代码练习
# 5中商品，56.75 72.91 88.50 26.37 68.51(字符串类型)
# 商品总金额:___元(算总价)
# 实数价格:___元(抹零)
a = "56.75"
b = "72.91"
c = "88.50"
d = "26.37"
e = "68.51"
a_float = float(a)
b_float = float(b)
c_float = float(c)
d_float = float(d)
e_float = float(e)
amount = a_float + b_float + c_float + d_float + e_float
print("商品总金额:" + str(amount) + "元")
real_amount = round(amount,0)运行
运算符:
运算符是特殊符号,用来运算,数学运算,比较运算,逻辑运算,位运算
算数运算:
+
-
*
/
%
//
**
赋值运算符:
=
+= (x+=y x=x+y)
-= *= %= //* **=
关系(比较)运算符:
< > <= >= == !=
是否在1~100之间:
a>1 and a<100
1<a<100
逻辑运算符:
or not and
表达式1 表达式2 表达式1 and 表达式2 表达式1 or 表达式2 表达式1 not表达式2
True True True True False
True Flase Flase True Flase
Flase True Flase True TruePython快捷键
快速注释: Ctrl + /
快速复制多行: Ctrl + D
快速另起一行: shirt + enterresult = 7/2
print(result)
print(type(result))运行
result = 7 % 7
print(result)
print(type(result))result = 2 ** 4
print(result)
print(type(result))运行
# 有一个人,期末考试有三门课:Python:95 English:92 C:89
# 算Python跟C分数差
# 算平均成绩
Python = 95
English = 92
c = 89
sub = Python - c
print("Python跟c的分数差为:" + str(sub))
sum = Python + English + c
avg = sum / 3
print("平均成绩:" + str(avg))运行
a = 1
a += 1
print(a)运行
print(bin(-7))运行
4-03
位运算符:
8字节的二进制数，32位
10 => 0000 0000 0000 1010
-10 => 1000 0000 0000 1010
-10 二进制运算:
0000 0000 0000 1010 原码
1111 1111 1111 0101 反码(取反)
+1
1111 1111 1111 0110 补码(反码+1,计算机实际存储的数字)
首尾代表正负号
-66
66原码 0000 0000 0100 0010
反码 1111 1111 1011 1101
+1
补码 1111 1111 1011 1110
位与 &
0000 0000 0000 1010 =>16
& 0000 0000 0000 1000 =>8
0000 0000 0000 1000 =>8
遇0则0
位或 |
0000 0000 0000 1010 => 10
| 0000 0000 0000 1000 => 8
0000 0000 0000 1010 => 10
遇1则1
位异或 ^
0000 0000 0000 1010 => 10
^ 0000 0000 0000 1000 => 8
0000 0000 0000 0010 => 2
相同为0,不同为1
取反 ~
0000 0000 0000 1010 => 10
~ 1111 1111 1111 0101 => 32757
1111 1111 1111 0101 => 32757
0变1,1变0
左位移 <<
0000 0000 0000 1010 => 10
<< 0000 0000 0001 0100 => 20
21 0000 0000 0001 0101 << 0000 0000 0010 1010 42
右位移 >>
0000 0000 0000 1010 => 10
>> 0000 0000 0000 0101 => 5
/2
运算符的优先级:
运算符
()
**
~ + -
* / % //
+ -
<< >>
&
^
|
< <= > >= == =!基本输入和输出:
input(x):输入函数
x指提示文字
返回值:字符串类型的值
print(x,...):输出函数
x指打印文字
如果有多个参数,依次进行打印,使用空格进行分隔
没有返回值
打印到本地磁盘的文件当中
fp = open(r"E:\demo.txt","a+")
print("这是一条输出语句",file=fp)
fp.close()
r:让转义字符失效input("输入一个数字:")运行
print("请输入一个数字:")
input()运行
a = input()
print(type(int(a)))运行
a = print("这是一个字符串")
print(type(a))运行
a = "我的名字是"
name = "阿尔法"
print(a + name)运行
a = "我的名字是"
name = "阿尔法"
print(a,name)运行
fp = open(r"E:\demo.txt","a+")
print("这是一条输出语句",file=fp)
fp.close()运行
打开磁盘
打开文件
4-10
# 第一步,输入父亲和母亲的身高
print("请输入父亲的身高:")
father = input()
father_f = float(father)
# father = float(input())
print("请输入母亲的身高")
mother = input()
mother_f = float(mother)
# 第二步,计算儿子的身高
son = (father_f + mother_f) * 0.54
# 第三步,儿子身高的输出
print("预测儿子的身高为:",son)运行
# 第一步，输入当天的行走步数
print("请输入当天行走的步数!")
steps = input()
# 第二步，计算一天小号的卡路里
calorie = int(steps) * 28
# 第三步，输出卡路里数
print("今天共消耗卡路里,",calorie,"(即",calorie/1000,"千卡)")运行
# 第一步，输入当天的行走步数
print("请输入当天行走的步数!")
steps = input()
# 第二步，计算一天小号的卡路里
calorie = int(steps) * 28
calorie_f = round(calorie/1000,2)
# 第三步，输出卡路里数
print("今天共消耗卡路里,",calorie,"(即",calorie_f,"千卡)")运行
print("今天共消耗卡路里,",calorie,"(即",calorie_f,"千卡)")
print(f"今天共消耗卡路里:{calorie}(即{calorie_f}千卡)")
print("今天共消耗卡路里: %s (即%s千卡)" % (calorie,calorie_f))运行
print("欢迎使用充值业务!")
name = input("请输入姓名:")
money = input("请输入充值金额:")
print("%s 先生/女士,充值成功,本次充值 %s 元" % (name,money))
print(f"{name} 先生,充值 {money} 元")运行
4-17
第三章:
顺序结构
选择语句:
if
if...else...
if...elif...else...
if的嵌套
循环语句:
while
for
嵌套循环
跳转语句:
break:中止整个循环
continue:跳出本次循环,执行下一次循环程序结构
顺序结构 选择结构 循环结构
选择语句:
if语句:
if 表达式:
代码块
如果if后面只跟; 一条语句:
if 表达式: 语句
if...else...语句:
if 表达式:
代码块1
else:
代码块2
简写:
b = a if a >0 else -a
else语句不可单独使用
if...elif...else
if 表达式:
代码块1
elif 表达式:
代码块2
...
else 表达式:
代码块n
elif和else都不可单独使用顺序结构
选择结构
循环结构
a = 1
if a < 10:
print(a)
print("判断为真")
if a >= 10:
print(a)
print("a大于等于10")运行
a = 11
if a < 10:
print(a)
print("判断为真")
if a >= 10:
print(a)
print("a大于等于10")运行
a = -9
if a > 0:
b = a
else:
b = -a
print(b)运行
# 需求 根据用户输入的玫瑰花数量 输出其表达的含义
number = int(input("请输入想送几朵玫瑰花:"))
if number == 1:
print("1朵:一心一意")
elif number == 10:
print("10朵:十全十美")
elif number == 99:
print("99朵:天长地久")
elif number == 520:
print("520朵:我爱你(๑′ᴗ‵๑)Ｉ Lᵒᵛᵉᵧₒᵤ❤")
elif number == 999:
print("999朵:求婚")
else:
print("意义不明,别瞎送!!!")4-24
循环语句:
while语句:
while 条件表达式:
循环体
初始变量
while 循环控制语句
循环体
变量变化
for循环:
for 迭代变量 in 对象:
循环体range函数:
作用:返回一个连续的整数对象
函数的声明:obj range(start,stop,step)
注意:参数都为数字类型
如果step>0,stop>start
如果step<0,stop<start
返回值不是一个数,是一个对象,对象当中包含了很多数
返回值 [start,stop)# 酒驾判断：
# 国家质量监督检验检疫局发布的《车辆驾驶人员血液、呼气酒精含量阈值与检验》中规定：车辆驾驶人员血液中的酒精含量
# 小于20mg/100ml不构成饮酒驾驶行为；酒精含量大于或等于20mg/100ml、小于80mg/100ml为饮酒驾车；酒精含量大于或者等
# 于80ml/100ml为醉酒驾车。
# 现编写一段python代码判断是否酒后驾车。
print("为了您和他人的安全,严禁酒后驾车!")
# 输入酒精含量
a = int(input("请输入每100ml血液的酒精含量:"))
if a <20:
print("不构成饮酒驾驶行为")
elif 20 <= a < 80:
print("饮酒驾车")
elif a >= 80:
print("醉酒驾车")运行
print("为了您和他人的安全,严禁酒后驾车!")
# 输入酒精含量
a = int(input("请输入每100ml血液的酒精含量:"))
# 构不构成酒驾行为
if a < 20:
print("构成饮酒驾驶行为")
if a >= 20:
if a < 80:
print("饮酒驾车")
else:
print("醉酒驾车")运行
print("为了您和他人的安全,严禁酒后驾车!")
# 输入酒精含量
a = int(input("请输入每100ml血液的酒精含量:"))
# 构不构成酒驾行为
if a < 0:
print("输入有误,必须大于等于0")
if 0 <= a <20:
print("构成饮酒驾驶行为")
if a >= 20:
if a < 80:
print("饮酒驾车")
else:
print("醉酒驾车")运行
# 计算1+2+...+100
a = range(1,101,1)
sum = 0
for i in a:
print(i)
sum = sum + i
print(sum)运行
# 打印5次hello World
for i in range(5):
print("hello Word")运行
a = 1
while a <= 5:
print("hello World")
a += 1运行
# 遍历字符串
string = "学习Python"
for char in string:
print(char)运行
for i in range(1,10):
for j in range(1,i+1):
if i != j:
print(str(j)+"×"+str(i)+"="+str(j*i)+" ",end='')
if i ==j:
print(str(j) + "×" + str(i) + "=" + str(j * i) + " ")
print()运行
5-8
Python语言基础练习
Python单行注释的符号是（//）
B
Python的代码块不适用大括号{}来控制类、函数以及其他逻辑判断
a = 1
if a == 1：{print("a = 1")}D:可以随意缩进
3.C
% 取余
4.D
=赋值 ==做判断
5.A
//不可以带小数
6.C
变量的命名规则(不能使用保留字,第一个字符不能使用数字,慎用o l)
7.C
复合运算符
8.B
9.C
10.C
//用来表示反义字符
代码前面+r/R,限制转义字符
11.B
12.C
#!指定Python环境
第二行限制编码集
or与and与用法:or两个满足其一,and两者都需满足条件
13.C
字符串拼接,需要将int类型转换为字符串类型
a = input("幸运数:\n")
a = int(a)
b = input("幸运数:\n")
b = int(b)
if b == a:
print(":幸运数字为:"+str(a)+",默契十足")
if b != a:
print(":幸运数字为:" + str(a) + ",很遗憾,没猜中"14.C
15.D
编程
father = float(input("请输入父亲的身高:\n"))
mother = float(input("请输入母亲的身高:\n"))
son = (father + mother) * 0.54
print("预测儿子身高:",son)运行
steps = int(input("请输入当天行走的步数!\n"))
kll = steps * 28
print("今天共消耗卡路里: "+str(kll)+"(即"+ str(kll/1000)+"千卡)")运行
5-15
s = "入门入土"
a = s[len(s)-1]
print(a)运行
s = "入门入土"
a = s[::1]
print(a)运行
s = "摸鱼划水"
a = '摸' in s
print(a)
print(type(a))运行
s = "摸鱼划水"
a = list(s)
print(a)
print(type(a))运行
list = [3.14,1,7,4,5,9,8]
print(sorted(list))运行
s = "青灯古酒"
print(sorted(s))运行
list1 = [3.14,1,7,4,3.12,5,9,0]
# list2 = [4,2,1]
list2 = ['摸鱼','划水']
print(list1 + list2)运行
list1 = [3.14,1,7,4,3.12,5,9,0]
# list2 = [4,2,1]
# list2 = ['摸鱼','划水']
a = reversed(list1)
print(a)运行
list1 = [3.14,1,7,4,3.12,5,9,0,True,'yiersan']
a = reversed(list1)
for i in a:
print(i,end=',')运行
5-22
list = [100,3.14,'字符串',range(10),[1,2,3]]
empty = []
print(len(empty))运行
a = list('list')
print(a)运行
a = list('字符串')
print(a)运行
a = list('字符串')
del a
print(a)运行
list = [100,3.14,'字符串',range(10),[1,2,3]]
print(list[-1])运行
list = [100,3.14,'字符串',range(10),[1,2,3]]
# print(list[-1])
a = list[0:len(list):2]
print(a)运行
list = list(range(10))
for index,item in enumerate(list):
print("第",index+1,"个元素,值为",item)运行
list = list(range(0,10,2))
print(list)运行
list = list(range(0,10,2))
list1 = ["你好","Python"]
list = list.append(list1)
print(list)运行
list = list(range(0,10,2))
list1 = ["你好","Python"]
list.append(list1)
print(list)运行
list = list(range(0,10,2))
list.insert(0,-1)
print(list)运行
list = list(range(0,10,2))
list.insert(3,-1)
print(list)运行
list = list(range(0,10,2))
list[0:3:1] = [1,2,3]
print(list)运行
list = list(range(0,10,2))
del list[2]
print(list)运行
list = list(range(0,10,2))
list.remove(6)
print(list)运行
list = [6,1,2,6,5,9,6]
list.remove(6)
print(list)运行
列表
概念:一系列特定顺序的元素来组成的,是python中内置的可变序列
格式:所有元素放在[]中,元素之间用,间隔
内容:整数 小数 字符串 实数 列表 元组 字典 自定义的对象 内置对象
特点:灵活
1.列表的创建
1.1使用赋值运算符创建列表
listneme = [element1,element2,...,element n]
元素只要是python支持的元素就可
注意:一般情况下,一个列表只放一种数据类型的元素，可以提高程序的可读性
1.2创建空列表
emptylist = []
1.3创建数值列表
list(data)
data一般就是各种序列
1.4创建指定长度的列表
2.删除列表
语法:del listname
补充:python有一套垃圾回收机制,会自动销毁不用的对象
3.访问列表
3.1通过索引访问
3.2通过切片
4.遍历列表
遍历:依次取出序列中每个元素,执行一定操作
4.1 for循环遍历
格式:
for item in listname:
# item的操作
4.2使用for循环和enumerate()
格式1:
for index,item in enumerate(list):
# index,item 的操作
格式2:
for var in enumerate(list):
#var输出格式:(index,item)
5.添加元素
5.1使用列表的相加
listname = list1 + list2
5.2使用append()函数
格式:listname.append(obj)
向原列表最后添加一个元素
5.3使用extend()函数
格式:listname.emtend(list)
将一个列表追加到原列表当中,类似于列表相加
5.4使用insert()函数
格式:listname.insert(index,obj)
向指定索引位置添加元素,指定位置及后面元素索引+1
6.修改元素
6.1通过索引
6.2通过切片
7.删除元素
7.1通过索引
格式:del listname[index]
7.2通过值删除元素
list.remove(obj)
删除第一个值为obj的元素5-29
list = [6,1,2,6,5,9,6]
index = list.index(6)
print(index)运行
list = [6,1,2,6,5,9,6]
sum = sum(list)
print(sum)运行
list = [8,1,2,6,5,9,6]
str_list = ['n','v','b','d','a']
str_list.sort(key = None)
print(str_list)运行
list = [8,1,2,6,5,9,6]
str_list = ['n','v','b','d','a']
str_list.sort(key = None,reverse = True)
print(str_list)运行
list = [8,1,2,6,5,9,6]
str_list = ['N','v','B','d','a']
a = sorted(list,key = None,reverse = False)
print(a)运行
list = [8,1,2,6,5,9,6]
list_new = [var * 0.5 for var in list]
print(list_new)运行
list = [8,1,2,6,5,9,6]
list_new = [var for var in list if var >5]
print(list_new)运行
list2 = [[1,2,3],[1,2,3],[1,2,3],[1,2,3]]
print(list[2])
print(list2[2][2])运行
代码：
根据身高体重计算BMI指数。BMI计算公式：BMI = 体重 / （身高 × 身高）并根据BMI指数判断是否健康：体重过轻范围：小于18.5体重正常范围：大于等于18.5，小于24.9体重偏重范围：大于等于24.9最终实现效果如下：
height = float(input("请输入身高(单位：米): "))
weight = float(input("请输入体重(单位：千克): "))
bmi = weight / (height ** 2)
print("您的BMI指数为：", bmi)
if bmi < 18.5:
print("您的体重过轻")
elif 18.5 <= bmi < 24.9:
print("您的体重正常")
else:
print("您的体重偏重")运行
打印九九乘法表最终运行结果如下图所示：
for i in range(1, 10):
for j in range(1, i+1):
print(f'{j}x{i}={i*j}\t', end='')
print()运行
"""
8.统计元素出现的次数
格式:listname.count(obj)
返回值:次数,int
9.获取指定元素的索引位置
格式:listname.index(obj)
参数:obj只能是列表中出现的元素,否则报错
返回值:索引,int
10.求和
格式:sum(listname[,start])
参数:listname:列表
start:在原有的求和基础上再加上start的值,可选参数,没有该参数则默认为0
返回值:根据列表的元素的数据类型来确定
11.排序
11.1 使用sort()方法
格式：listname.sort(key=None, reverse=False)
参数：key：可选参数，默认值为None，用于指定排序规则
例如，key=str.lower表示忽略大小写进行排序
reverse：可选参数，默认为False，False为升序，True为降序
返回值：不指定就是对愿列表进行排序，指定就是在对原列表进行排序的基础上，复制一个排序后的列表
注意：对中文不支持
11.2 使用sorted()方法
格式：sorted(listname, key=None, reverse=False)
参数：listname: 列表
key：可选参数，默认值为None，用于指定排序规则
例如，key=str.lower表示忽略大小写进行排序
reverse：可选参数，默认为False，False为升序，True为降序
返回值：不指定就是原列表没有变化，指定就是生成一个排序后的列表
12. 列表推导式：快速生成一个列表
12.1 生成指定范围的数值列表
格式： list = [Expression for var in range]
参数：Expression：表达式，用来计算新列表的元素
var：循环变量
range：range对象
list：生成的新列表
12.2 根据列表生成指定要求的列表
格式：list = [Expression for var in list]
参数：Expression：表达式，用来计算新列表的元素
var：循环变量
list：原列表
list：生成的新列表
12.3 从列表中选择符合条件的元素组成新的列表
格式：list = [Expression for var in list if condition]
参数：Expression：表达式，用来计算新列表的元素
var：循环变量
list：原列表
condition：表达式，指定筛选的条件
list：生成的新列表
二维列表：
列表中所有元素都为列表
1. 直接创建
2. 通过for循环嵌套
3. 使用列表推导式
"""
# list = [6,1,2,6,5,9,6]
# amount = list.count(6)
# print(amount)
# list = [6,1,2,6,5,9,6]
# index = list.index(6)
# print(index)
# list = [6,1,2,6,5,9,6]
# sum = sum(list)
# print(sum)
# list = [8,1,2,6,5,9,6]
# str_list = ['n','v','b','d','a']
# str_list.sort(key = None)
# print(str_list)
# list = [8,1,2,6,5,9,6]
# str_list = ['n','v','b','d','a']
# str_list.sort(key = None,reverse = True)
# print(str_list)
# list = [8,1,2,6,5,9,6]
# str_list = ['N','v','B','d','a']
# a = sorted(list,key = None,reverse = False)
# print(a)
# list = [random.randbytes(1) for i in range(10)]
# print(list)
# 生成一个长度为10,元素为1到100的随机组成的列表
# list1 = [random.randint(1,100) for var in range(20)]
# print(list1)
# a = random.randint(1,10)
# print(a)
# list = [8,1,2,6,5,9,6]
# list_new = [var * 0.5 for var in list]
# print(list_new)
# list = [8,1,2,6,5,9,6]
# list_new = [var for var in list if var >5]
# print(list_new)
# list1 = []
# for i in range(4):
# list1.oppend([])
# for j in range(5):
# list[i].append(j)
# print(list1)
# list = [[j for j in range(5)]for i in range(4)]
# print(list)
list2 = [[1,2,3],[1,2,3],[1,2,3],[1,2,3]]
print(list[2])
print(list2[2][2])6-5
"""
注释:
#
''''''
"""""""
# -*- coding:掩码 -*-
# coding=掩码
代码缩进:
保留字:if slse while for in print
变量的命名规范:
1.变量名一定要符合标识的命名规范
2.变量名不能是保留字
3.慎用0和l
4.选择有意义的单词作为变量名
变量的定义格式:
变量名 = value
注意:定义变量的时候不需要声明变量数据类型
查看变量的数据类型:
内置函数:type(变量) 返回值就是变量的数据类型
查看变量的内存引用地址:
内置函数:id(变量) 返回值是该变量在内存当中引用地址
常量的命名规范:
大写字母和下划线组成:STUDENT_SUM = value
"""
"""
基本数据类型:
数字类型
整数类型:int
十进制
二进制
八进制
注意:以0O或0o开头
十六进制
注意以0X或0x开头
浮点类型：小数float
e = 2.718
注意：浮点类型计算时有精度问题
复数 complex
格式：a+bj （a是实部，b是虚部）
z = 1 + 2j
字符串类型：str
定义格式：
变量 = '内容' 可以通过\或者()换行,打印为一行
变量 = "内容" 可以通过\或者()换行,打印为一行
变量 = '''内容''' 或三双引号
可以通过回车的方式换行,且打印出来与字符串格式相同
注意:
字符串首尾符号保持一致
引号可以嵌套使用,被嵌套的字符串定义符也会变为字符串的一部分
三双引号嵌套双引号的时候,不能尾接触
转义字符:
\n:换号
\:续行
\0:空 null
\":"转换成字符串
\':'转换成字符串
\\:\ 转换成字符串
\0dd :八进制数,dd指字符,例如:\012 代表换行
\x0a :十六进制,0a指字符,例如:\x0a代表换行
限制转义字符:
最喜爱字符串前面加上R或者r,限制转义字符的功能,而且会把转义字符完成打印出来
布尔类型:Boolean
主要表示:真假
True 或 False (都是保留字)
1 0
布尔类型可以进行计算,但是不推荐
对象的假值:
1.Flase 和None
2.数字当中0,包括整数0,小数0.0,复数虚数0
3.空序列,包括字符串 空列表 空字典
4.自定义对象的实例,该对象的__bool__方法的返回False 或者 __len__返回0
数据类型转换:
1.int(x):x代指对象,返回值是一个整数类型,对象->整数
x为字符串:字符串应全为整数
x为小数:只保留整数部分
x不能是负数
x为布尔类型:True = 1 False = 0
2.float(x):x呆滞对象,返回值是一个浮点类型的值,对象->浮点类型
x为字符串:字符串应全为整数,除了复数
x为整数:整数,0
x不能是负数
x为布尔类型:True = 1.0 False = 0.0
3.str(x):x代指对象,返回值是一个字符串,对象->字符串
x可以是所有基本数据类型
4.complex(real,[imag]):real代表实数部分,imag代表虚数部分,返回值是一个复数,创建一个复数
complex(x) => 1+0j
5.repr(x):x代指对象,返回值是一个字符串,对象->表达式字符串
x可以是所有基本数据类型
6.eval（x):x代指字符串对象.返回值根据字符串内容定,字符串对象->数字类型
x为整数字符串,返回值为整数类型
x为浮点字符串:返回值为浮点类型
x为复数字符串:返回值为复数
7.chr(x):x代指整数,返回值是一个字符,整数->字符
参照的是ASCII表
48:0
65:A
97:a
8.ord(x):x代指字符,返回值一个整数,字符->整数
9.hex(x):x代指整数,返回值是一个十六进制字符串,整数->字符串
10.oct(x):x代指整数,返回值是一个八进制字符串,整数->字符串
11.bin(x):x代指整数,返回值是一个二进制字符串,整数->字符串
12.round(x[,ndigits]):x代指浮点数,ndigits代指位数,返回值是一个四舍五入的浮点数或整数
运算符:
运算符是特殊符号,用来运算,数学运算,比较运算,逻辑运算,位运算
算数运算:
+
-
*
/
%
//
**
赋值运算符:
=
+= (x+=y x=x+y)
-= *= %= //* **=
关系(比较)运算符:
< > <= >= == !=
是否在1~100之间:
a>1 and a<100
1<a<100
逻辑运算符:
or not and
表达式1 表达式2 表达式1 and 表达式2 表达式1 or 表达式2 表达式1 not表达式2
True True True True False
True Flase Flase True Flase
Flase True Flase True True
Flase Flase Flase Flase True
a = 50
if a > 60 or a < 100
运算符的优先级:
运算符
()
**
~ + -
* / % //
+ -
<< >>
&
^
|
< <= > >= == =!
基本输入和输出:
input(x):输入函数
x指提示文字
返回值:字符串类型的值
print(x,...):输出函数
x指打印文字
如果有多个参数,依次进行打印,使用空格进行分隔
没有返回值
打印到本地磁盘的文件当中
fp = open(r"E:\demo.txt","a+")
print("这是一条输出语句",file=fp)
fp.close()
r:让转义字符失效
第三章:
顺序结构
选择语句:
if
if...else...
if...elif...else...
if的嵌套
循环语句:
while
for
嵌套循环
跳转语句:
break:中止整个循环
continue:跳出本次循环,执行下一次循环
程序结构
顺序结构 选择结构 循环结构
选择语句:
if语句:
if 表达式:
代码块
如果if后面只跟; 一条语句:
if 表达式: 语句
if...else...语句:
if 表达式:
代码块1
else:
代码块2
简写:
b = a if a >0 else -a
else语句不可单独使用
if...elif...else
if 表达式:
代码块1
elif 表达式:
代码块2
...
else 表达式:
代码块n
elif和else都不可单独使用
循环语句:
while语句:
while 条件表达式:
循环体
初始变量
while 循环控制语句
循环体
变量变化
for循环:
for 迭代变量 in 对象:
循环体
range函数:
作用:返回一个连续的整数对象
函数的声明:obj range(start,stop,step)
注意:参数都为数字类型
如果step>0,stop>start
如果step<0,stop<start
返回值不是一个数,是一个对象,对象当中包含了很多数
返回值 [start,stop)
循环嵌套:
进入外循环,如果有一个内循环,则会完全执行内循环之后再执行外循环
序列:
概念:一种常用的数据存储的方式,在数学当中又称为数列,是按照一定的顺序排列的一列数
数据结构:序列是基本的数据结构,在Python有5个常用的序列结构:列表 元组 集合 字典 字符串
可变序列:可以增删改的序列就是可变序列
Python中的序列
概念:一块用于存放多个值的连续内存空间,并且按照一定顺序排列,每一个值(称为元素)都分配一个数字,称为索引或者位置
索引:
序列中每一个元素都有一个编号,也称为索引.从0开始的整数,第n个元素的索引(n-1)
Python中索引可以为负数,最右边的索引为-1,依次向左-1,从-1开始,从右往左依次-1
格式:序列号[索引]
切片:
访问序列中的元素(一定范围内的元素)
生成一个序列的片段
格式:序列号[start:end:step]
start:起始索引(包括该位置),如果不指定,默认为0
end:结束索引(不包括该位置),如果不指定,默认为序列的长度
step:步长,如果省略,默认为1
如果要复制整个序列,序列名[:]
序列的相加:
python中允许两种相同类型的序列号进行相加,不会去重
序列的乘法:
把原来的序列内容重复n次,填入新的序列当中
初始化一个指定长度的序列
检查某个元素是否是序列的成员:
语法:value in 序列号
返回值;布尔类型,True或者False
计算序列的长度:
int len(序列号)
计算序列的最大值最小值:
value max(序列名)
value min(序列号)
常用序列的内置函数:
value max(序列名)
value min(序列号)
list list(序列号):将一个序列号转换成list列表
str str(序列号):将一个序列转换成字符串
value sum(序列号):求和,字符串不能使用
list sorted(序列号):排序
列表
概念:一系列特定顺序的元素来组成的,是python中内置的可变序列
格式:所有元素放在[]中,元素之间用,间隔
内容:整数 小数 字符串 实数 列表 元组 字典 自定义的对象 内置对象
特点:灵活
1.列表的创建
1.1使用赋值运算符创建列表
listneme = [element1,element2,...,element n]
元素只要是python支持的元素就可
注意:一般情况下,一个列表只放一种数据类型的元素，可以提高程序的可读性
1.2创建空列表
emptylist = []
1.3创建数值列表
list(data)
data一般就是各种序列
1.4创建指定长度的列表
2.删除列表
语法:del listname
补充:python有一套垃圾回收机制,会自动销毁不用的对象
3.访问列表
3.1通过索引访问
3.2通过切片
4.遍历列表
遍历:依次取出序列中每个元素,执行一定操作
4.1 for循环遍历
格式:
for item in listname:
# item的操作
4.2使用for循环和enumerate()
格式1:
for index,item in enumerate(list):
# index,item 的操作
格式2:
for var in enumerate(list):
#var输出格式:(index,item)
5.添加元素
5.1使用列表的相加
listname = list1 + list2
5.2使用append()函数
格式:listname.append(obj)
向原列表最后添加一个元素
5.3使用extend()函数
格式:listname.emtend(obj)
将一个列表追加到原列表当中,类似于列表相加
往列表后面追加元素,跟+ 作用一致
5.4使用insert()函数
格式:listname.insert(index,obj)
向指定索引位置添加元素,指定位置及后面元素索引+1
6.修改元素
6.1通过索引
6.2通过切片
7.删除元素
7.1通过索引
格式:del listname[index]
7.2通过值删除元素
list.remove(obj)
删除第一个值为obj的元素
8.统计元素出现的次数
格式:listname.count(obj)
返回值:次数,int
9.获取指定元素的索引位置
格式:listname.index(obj)
参数:obj只能是列表中出现的元素,否则报错
返回值:索引,int
10.求和
格式:sum(listname[,start])
参数:listname:列表
start:在原有的求和基础上再加上start的值,可选参数,没有该参数则默认为0
返回值:根据列表的元素的数据类型来确定
11.排序
11.1 使用sort()方法
格式：listname.sort(key=None, reverse=False)
参数：key：可选参数，默认值为None，用于指定排序规则
例如，key=str.lower表示忽略大小写进行排序
reverse：可选参数，默认为False，False为升序，True为降序
返回值：不指定就是对愿列表进行排序，指定就是在对原列表进行排序的基础上，复制一个排序后的列表
注意：对中文不支持
11.2 使用sorted()方法
格式：sorted(listname, key=None, reverse=False)
参数：listname: 列表
key：可选参数，默认值为None，用于指定排序规则
例如，key=str.lower表示忽略大小写进行排序
reverse：可选参数，默认为False，False为升序，True为降序
返回值：不指定就是原列表没有变化，指定就是生成一个排序后的列表
12. 列表推导式：快速生成一个列表
12.1 生成指定范围的数值列表
格式： list = [Expression for var in range]
参数：Expression：表达式，用来计算新列表的元素
var：循环变量
range：range对象
list：生成的新列表
12.2 根据列表生成指定要求的列表
格式：list = [Expression for var in list]
参数：Expression：表达式，用来计算新列表的元素
var：循环变量
list：原列表
list：生成的新列表
12.3 从列表中选择符合条件的元素组成新的列表
格式：list = [Expression for var in list if condition]
参数：Expression：表达式，用来计算新列表的元素
var：循环变量
list：原列表
condition：表达式，指定筛选的条件
list：生成的新列表
二维列表：
列表中所有元素都为列表
1. 直接创建
2. 通过for循环嵌套
3. 使用列表推导式
"""6-12
"""
1-100的求和
使用range函数
总和的临时变量sum
range对象循环相加
"""
a = range(1,101)
sum = 0
for i in a:
sum += i
print(sum)运行
a = [59,34,64,72,56]
sum = 0
for i in a:
sum += i
avg = sum / len(a)
print(avg)运行
a = [59,34.567,64.123,72.731,56]
sum = 0
for i in a:
sum += i
avg = sum / len(a)
avg = round(avg,2)
print(avg)运行
"""
对列表的数做统一的操作
有一个数的序列
循环遍历,对每一个元素进行计算/通过列表推导式
重新定义一个改变后的序列
"""
a = [59,34.567,64.123,72.731,56]
price = []
for i in a:
i = i * 0.85
i = round(i,2)
price.append(i)
print(price)
a = [59,34.567,64.123,72.731,56]
price = [round(i * 0.85,2) for i in a]
print(price)运行
"""
输入一个数
对输入价格进行计算
输出
"""
a = input("请输入一个价格:")
b = float(a) * 0.85
print("打折后的价格:",b)运行
"""
猜数字小游戏,从1-10中随机选一个数,输入自己猜的数
创建一个随机数(1-10)
输入自己猜的数
猜大了,重新输入然后进行判断
猜小了,重新输入然后进行判断
猜对了,退出程序
"""
random = random.randint(1, 10)
while True:
a = input("猜的数：")
a = int(a)
if a == -1:
break
elif a == random:
print("猜对了")
break
elif a > random:
print("猜大了")
elif a < random:
print("猜小了")
print("游戏结束")"""
1.变量的命名规则
2.for 循环跟while循环的格式
3.break continue pass语句
4.列表推导式
5.真值测试,为False的情况
"""
"""
创建一个随机数(1-100)列表,长度为10
"""
list1 = [random.randint(1,100) for i in range(10)]
print(list1)运行
a = 1
if a:
print(True)
else:
print(False)运行
标签：10,0000,Python,list,笔记,学习,字符串,print,运行 From： https://blog.51cto.com/u_15964895/6577256