黑马程序员python教程，8天python从入门到精通，学python看这套就
从开始到元组基本操作的笔记，包括所有代码和运行结果（都是自己在pycharm上运行过的）
win+r打开运行框（输入cmd)
ctrl+a全选
ctrl+f搜索
ctrl+c\v\x复制、粘贴、剪切
ctrl+d复制当前行代码
ctrl+shift+上下 将当前行代码上下移
ctrl+shift+f10运行当前代码
ctrl+shift+s截图
python解释器运行文件 文本格式
\
eg. test.py
python "C:\Users\86198\Desktop\test.py.txt"
字面量==常量（C++）
单行注释#
多行注释"""..."""
变量
定义 变量名=变量值
print( , , ,..., )输出多个内容
type()查看数据类型，有返回值
变量可以存储类型信息（即type()的返回值）
print(type(11))
\
float_type = type(11.345)
print(float_type)
\
name = "哦莫"
name_type = type(name)
print(name_type)
运行结果：
<class 'int'>
<class 'float'>
<class 'str'>
数据类型转换,有返回值
int(x)
float(x)
str(x)
\
浮点数转整型数会丢失小数精度
True,False,None是关键字
变量命名规范
1.见名知意
2.单词用下划线分隔
3.英文字母全小写
\
eg.score_maths
算数运算符
+-*/
// 整除
% 取余
** 指数
复合赋值运算符
+=
-=
/
%=
**=
//=
字符串定义的三种方法
1.单引号定义法 name = '哦莫'
2.双引号定义法 name = "哦莫"
3.三双引号定义法 name = """哦莫"""
\
三双引号定义法支持换行操作
字符串的引号嵌套
1.单引号内嵌双引号
2.双引号内嵌单引号
3.使用转移字符(\)来将引号接除效用，变成普通字符串
eg.
name = "\"哦莫"
print(name)
\
运行结果
“哦莫
字符串拼接
1.字面量和字面量，变量和变量，字面量和变量拼接用"+"
eg.print("om"+"wsxx")
\
运行结果
omwsxx
(与逗号输出多个内容的区别：逗号隔开的多个内容输出时有空格，拼接后形成一个整体没有空格）
（只能是字符串类型之间的拼接，非字符串类型如整型和浮点型需要转换后才能拼接）
2.字符串格式化，占位拼接（类似c++的格式化输出）
%s 将内容转换为字符串，放入占位位置
%d 将内容转换为整数，放入占位位置
%f 将内容转换为浮点型，放入占位位置
eg.
name = "字节跳动“
set_up_year = 2013
stock_price = 19.99
message = "我是：%s,我成立于：%d，我今天的股价是：%f" %(name,set_up_year,stock_price)
print(message)
\
运行结果
我是：字节跳动,我成立于：2013，我今天的股价是：19.990000
print("我是：%s,我成立于：%d，我今天的股价是：%f"%(name,set_up_year,stock_price))
\
运行结果
我是：字节跳动,我成立于：2013，我今天的股价是：19.990000
3.字符串格式化快速写法
f"内容{变量}"（format格式化）
\
name = "字节跳动“
set_up_year = 2013
stock_price = 19.99
print(f"我是{name},我成立于：{set_up_year},我今天股票的价格是：{stock_price}")
\
运行结果
我是字节跳动,我成立于：2013,我今天股票的价格是：19.99（没有精度控制）
格式化的精度控制
辅助符号"m.n"
m控制宽度，设置宽度小于数字自身，不生效
n控制小数点精度会进行小数的四舍五入
eg.
%5d
11->[space][space][space]11
\
%.2f
11.345->11.35
\
%7.2f
11.345->[space][space]11.35
补：表达式格式化
print("1*1的结果是：%d" %(1*1))
print("字符串在python中的类型名是：%s" %s type("字符串"))
数据输入input()(默认输入数据类型是字符串）
name = input()
提示语句可以在括号内
eg.
name = input("Who are you?")
print("wow,%s is a nice name." %name)
布尔类型和比较运算符
eg.
result = 10>5
print(f"10>5的结果是：{result},类型是：{type(result)}")
\
运行结果
10>5的结果是：True,类型是：<class 'bool'>
\
==
!=
>
<
>=
<=
if语句
if 要判断的条件:
条件成立时，要做的事情
（四格缩进判断归属）
if else语句
if 要判断的条件:
条件成立时，要做的事情
else:
条件不成立时，要做的事情
if_elif_else语句
if 条件1:
条件1成立时，要做的事情
elif 条件2:
条件2成立时，要做的事情
......
elif 条件N:
条件N成立时，要做的事情
else:
所有条件都不满足时，要做的事情
eg.
num = 10
if int(input("请输入第一次猜想的数字：")) != 10:
if int(input("不对，再猜一次：")) != 10:
if int(input("不对，再猜最后一次："))!=10:
print("全都猜错啦，我想的是：10")
else:
print("恭喜你猜对啦")
else:
print("恭喜你猜对啦")
else:
print("恭喜你猜对啦")
\判断语句的嵌套，注意缩进
eg.
num = 10
if int(input("请输入第一次猜想的数字：")) == 10:
print("恭喜你猜对啦")
elif int(input("不对，再猜一次：")) == 10:
print("恭喜你猜对啦")
elif int(input("不对，再猜最后一次："))==10:
print("恭喜你猜对啦")
else:
print("全都猜错啦，我想的是：10")
\
语句从上至下执行
import random
num = random.randint(1, 10)
guess_num = int(input("Please input your number:"))
if guess_num == num:
print("very good")
else:
if guess_num > num:
print("less")
else:
print("more")
guess_num = int(input("Please input once more"))
if guess_num == num:
print("good")
else:
if guess_num > num:
print("less")
else:
print("more")
guess_num = int(input("Please input once more"))
if guess_num == num:
print("well done")
else:
if guess_num > num:
print("less")
else:
print("more")
print("No chance")
print(num)
循环语句while
while 条件:
...
...
...
\
eg.
i = 0
while i < 100:
print("小美，我喜欢你")
i += 1
\
eg.
i = 0
sum = 0
while i < 100:
i += 1
sum += i
print(sum)
\
eg.
import random
num = random.randint(1,100)
flag = True
while flag:
guess_num = int(input("please input your num"))
if guess_num == num:
print("good")
flag = False
else:
if guess_num > num:
print("less")
else:
print("more")
while的嵌套
eg.舔狗的故事
i = 0
while i < 100:
print(f"今天是第{i}天，准备表白......")
j = 1
while j < 10:
j += 1
print(f"送给小美第{j}支玫瑰花")
print("小美，我喜欢你")
i += 1
print(f"坚持到第{i}天，表白成功")
\
eg.打印九九乘法表
补充：print不换行
print("hello",end='')
print("world",end='')
运行结果
helloworld
\
i = 1
j = 1
flag = True
while flag:
while j <= 9:
print(i,"*",j,"=",i*j)
if(i == 9 & j == 9):
flag = False
j += 1
i += 1
j = i
#一式一行版
eg.打印九九乘法表
i = 1
j = 1
flag = True
while flag:
while i <= j:
if i == j:
print(i,"*",j,"=",i*j," ")
else:
print(i,"*",j,"=",i*j," ",end='')
if(i == 9 & j == 9):
flag = False
i += 1
j += 1
i = 1
\
每层i 1->j j++
终止条件 i == j
完全终止条件 i == j == 9
判断后进行换行
\
运行结果
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
eg. 九九乘法表
\
制表符对齐换行法
\
i = 1
j = 1
flag = True
while flag:
while i <= j:
print(i,"*",j,"=",i*j," ",'\t',end='')
if(i == 9 & j == 9):
flag = False
i += 1
print()#实现换行
j += 1
i = 1
\
运行结果
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
#制表符应用
print("hello world")
print("om xiao")
print("hello\t\tworld")
print("ommmmmmm\txiao")
#\t代替空格，等效于按下tab键,如果无法对齐，可以试着多打一个制表符
\
运行结果
hello world
om xiao
hello world
ommmmmmm xiao
for循环
#遍历字符串
name = "omwsxx"
for x in name:
print(x)
\区别于c++,for循环无法定义循环条件，无法构建无限循环
#语法
for 临时变量 in 待处理数据集(序列类型，即内容可以一个个依次取出的一种类型，包括字符串，列表，元组):
循环满足条件时执行的代码
#eg.字符数统计
cnt=0
name = "itheima is a brand of itcast"
for x in name:
if x == 'a':
cnt += 1
print(cnt)
\
运行结果
4
range语句
#range(num)
range(5)
(0,1,2,3,4)
\
#range(num1,num2)
range(5,10)
(5,6,7,8,9)
\
#range(num1,num2,step)
range(5,10,2)
(5,7,9)
eg.
for x in range(10):
print(x)
运行结果
0
1
2
3
4
5
6
7
8
9
eg.
cnt = 0
for x in range(1, 100):
if x % 2 == 0:
cnt += 1
print(cnt)
\统计偶数个数
运行结果
49
(这里不能用//?
//得到的是商！只有1整除2商0，求余得到的才是余数)
\
p.s.作用域
for i in range(5)
print(i)
print(i)#i是for循环内部变量，在外面理论上报错，实际上可以运行
for循环嵌套
eg.舔狗日记plus版
for i in range(1 ,101):
print(f"今天是向小美表白的第{i}天")
for j in range(1,11):
print(f"向小美送第{j}朵玫瑰花")
print("哦耶哦耶表白成功")
eg.九九乘法表
for j in range(1,10):
for i in range(1,j+1):
print(f"{i}*{j}={i*j}\t",end='')
print()
\
运行结果
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
#continue跳过当前循环
#break终止循环
eg.
for i in range(1,3):
print("语句1")
for j in range(1,3):
print("语句2")
continue
print("语句3")#不执行
print("语句4")
\
运行结果
语句1
语句2
语句2
语句4
语句1
语句2
语句2
语句4
eg.
for i in range(1,6):
print("语句1")
for j in range(1,6):
print("语句2")
break
print("语句3")#内层循环终止
print("语句4")
\
运行结果
语句1
语句2
语句4
语句1
语句2
语句4
语句1
语句2
语句4
语句1
语句2
语句4
语句1
语句2
语句4
eg.黑心资本家
import random
sum = 10000
for x in range(1,21):
score = random.randint(1,10)
if score < 5:
print(f"员工{x},绩效分{score},低于5，不发工资")
else:
sum -= 1000
print(f"向员工{x}发放工资1000元,账户余额{sum}元")
if sum == 0:
print("这个月工资发完了，下个月再来领取吧")
break
\
运行结果
向员工1发放工资1000元,账户余额9000元
向员工2发放工资1000元,账户余额8000元
员工3,绩效分4,低于5，不发工资
向员工4发放工资1000元,账户余额7000元
向员工5发放工资1000元,账户余额6000元
员工6,绩效分2,低于5，不发工资
向员工7发放工资1000元,账户余额5000元
员工8,绩效分1,低于5，不发工资
向员工9发放工资1000元,账户余额4000元
向员工10发放工资1000元,账户余额3000元
员工11,绩效分4,低于5，不发工资
员工12,绩效分2,低于5，不发工资
员工13,绩效分3,低于5，不发工资
向员工14发放工资1000元,账户余额2000元
员工15,绩效分3,低于5，不发工资
向员工16发放工资1000元,账户余额1000元
向员工17发放工资1000元,账户余额0元
这个月工资发完了，下个月再来领取吧
函数
#组织好的，可重复使用的，用来实现特定功能的代码段
eg.统计字符串长度
def my_len(_str):
cnt = 0
for x in _str:
cnt += 1
print(cnt)
my_len("omwsxx")
\
运行结果
6
#函数定义格式
def 函数名(传入参数)
函数体
return 返回值
(函数在遇到return之后就结束了)
\
#函数调用格式
函数名(参数)
eg.有返回值加法函数
def my_add(x, y):
result = x + y
return result
print(my_add(2,3))
\
(注意用变量接收或者输出，仅函数调用不能作为一条完整的语句)
运行结果
5
#函数返回值None类型
None 类型是<class 'NoneType'>
无返回值的函数实际上返回了None
eg.
def say_hi():
print("hello")
result = say_hi()
print(result)
print(type(result))
\
运行结果
hello
None
<class 'NoneType'>
#None在if判断上等同于False
#None在定义变量上暂不赋予具体值时可以用None来代替
#函数说明文档
多行注释解释函数
#函数的嵌套调用
#变量在函数中的作用域
全局变量，局部变量
global关键字声明全局变量
eg.
num = 100
def test_a():
num = 200
print(num)
test_a()
print(num)
def test_b():
global num
num = 200
print(num)
test_b()
print(num)
\
运行结果
200
100
200
200
eg.Jay Choe的存款
money = 5000000
name = None
switch = None
flag = True
def home_back():
global switch
print("""Hello,how can I help you?You can choose from 1~3.1 stands for money-checking,2 stands for money-putting-in,3 stands for money-getting-out,4 stands for exiting""")
switch = int(input())
def check_money():
global money
print(f"您好，您当前的余额是{money}元")
home_back()
def put_in():
global money
money += int(input("您好，请问您需要存入的钱款是多少元"))
check_money()
def get_out():
global money
money -= int(input("您好，请问您需要提出的钱款是多少元"))
check_money()
home_back()
while flag:
if switch == 1:
check_money()
elif switch == 2:
put_in()
elif switch == 3:
get_out()
else:
flag = False
\
测试集
1
2
5000
3
5000
4
\
运行结果
C:\pythonProject\pythonProject1\venv\Scripts\python.exe C:\pythonProject\pythonProject1\main.py
Hello,how can I help you?You can choose from 1~3.1 stands for money-checking,2 stands for money-putting-in,3 stands for money-getting-out,4 stands for exiting
1
您好，您当前的余额是5000000元
Hello,how can I help you?You can choose from 1~3.1 stands for money-checking,2 stands for money-putting-in,3 stands for money-getting-out,4 stands for exiting
2
您好，请问您需要存入的钱款是多少元5000
操作成功，当前余额5005000元
Hello,how can I help you?You can choose from 1~3.1 stands for money-checking,2 stands for money-putting-in,3 stands for money-getting-out,4 stands for exiting
3
您好，请问您需要提出的钱款是多少元5000
操作成功，当前余额5000000元
Hello,how can I help you?You can choose from 1~3.1 stands for money-checking,2 stands for money-putting-in,3 stands for money-getting-out,4 stands for exiting
4
Process finished with exit code 0
数据容器(即数据结构)
一个变量可以记录一组数据
name_list = ['张三','李四','王五','赵六']
列表list、元组tuple、字符串str、集合set、字典dict
#列表
(元素可以是不同类型的数据)
定义变量
变量名 = [元素1，元素2，元素3，...]
\
定义空列表
变量名称 = []
变量名称 = list()
eg.列表元素可以数据类型不同
my_list = ['omwsxx',True,666]
print(my_list)
print(type(my_list))
\
运行结果
['omwsxx', True, 666]
<class 'list'>
eg.嵌套列表
my_list = [['omwsxx',True,666],[666,666,999]]
print(my_list)
print(type(my_list))
\
运行结果
[['omwsxx', True, 666], [666, 666, 999]]
<class 'list'>
#列表的下标索引
eg.正向索引
my_list = [666,"omwsxx",True]
print(my_list[0])
print(my_list[1])
print(my_list[2])
\
运行结果
666
omwsxx
True
eg.反向索引
my_list = [666,"omwsxx",True]
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
\
运行结果
True
omwsxx
666
#列表的常用操作
定义
使用下标索引获取值
插入
删除
清空
修改
统计
eg.1抽象类错误使用
class Student:
def my_add(a, b):
result = a + b
return result
student = Student()###
result = student.my_add(3,5)
print(result)
\
运行结果
C:\pythonProject\pythonProject1\venv\Scripts\python.exe C:\pythonProject\pythonProject1\main.py
Traceback (most recent call last):
File "C:\pythonProject\pythonProject1\main.py", line 6, in <module>
result = student.my_add(3,5)
^^^^^^^^^^^^^^^^^^^
TypeError: Student.my_add() takes 2 positional arguments but 3 were given
Process finished with exit code 1
eg.2正确结果是直接使用抽象类
class Student:
def my_add(a,b):
result = a + b
return result
print(Student.my_add(2,3))
\
运行结果
5
eg.3抽象类重命名后使用
class Student:
def my_add(a,b):
result = a + b
return result
student = Student
print(student.my_add(2,3))
\
运行结果
5
#查找某元素下标
语法：
列表.index(元素)
index是列表对象内置函数，有返回值
#修改特定位置元素值
语法：
列表[下标]=值
#插入元素
语法：
列表.insert(插入位置序号(从0开始),插入元素)
insert是列表对象内置函数
eg.列表插入
my_list = ["itheima",666,"omwsxx"]
my_list.insert(1,"999")###插在1号位（序号从0开始）
print(my_list)
\
运行结果
['itheima', '999', 666, 'omwsxx']
#追加一个元素
语法：
列表.append(元素)
将指定元素追加到列表尾部,无返回值
eg.列表追加一个元素
my_list = ["itheima",666,"omwsxx"]
my_list.append("999")
print(my_list)
\
运行结果
['itheima', 666, 'omwsxx', '999']
#追加多个元素
语法：
列表.extend(其他数据容器(集)),无返回值
eg.列表追加一个数据集
my_list = ["itheima",666,"omwsxx"]
my_list.extend([2,3,4])
print(my_list)
\或
my_list = ["itheima",666,"omwsxx"]
my_list2 = [2,3,4]
my_list.extend(my_list2)
print(my_list)
\
运行结果
['itheima', 666, 'omwsxx', 2, 3, 4]
#删除元素
语法：
1.del 列表[下标]无返回值
2.列表.pop(下标)有返回值
eg.删除元素
my_list = ["itheima",666,"omwsxx"]
my_list.pop(0)
print(my_list)
del my_list[0]
print(my_list)
\
运行结果
[666, 'omwsxx']
['omwsxx']
#删除某元素在列表中的第一个匹配项
语法:
列表.remove(元素)
eg.
my_list = ["itheima",666,"omwsxx",666]
my_list.remove(666)
print(my_list)
\
运行结果
['itheima', 'omwsxx', 666]
#清空列表内容
语法:
列表.clear()
eg.
my_list = ["itheima",666,"omwsxx",666]
my_list.clear()
print(my_list)
\
运行结果
[]
#统计某元素在列表中的数量
语法:
列表.count(元素)，有返回值
eg.
my_list = ["itheima",666,"omwsxx",666]
cnt = my_list.count(666)
print(cnt)
\
运行结果
2
#统计列表内有多少元素(非内置函数，有返回值)
语法:
len(列表)
eg.
my_list = ["itheima",666,"omwsxx",666]
print(len(my_list))
\
运行结果
4
#列表特点
可容纳多个元素(上限为2**63-1)
可以容纳不同类型的元素(混装)
数据是有序存储的(下标)
允许重复数据存在
可以修改(增加或者删除元素等)
eg.练习
my_list = [21,25,21,23,22,20]
my_list.append(31)
my_list.extend([29,33,30])
print(my_list.pop(0))
print(my_list.pop(-1))
print(my_list.index(31))
\
运行结果
21
30
5
#遍历列表元素
my_list = [21,25,21,23,22,20]
index = 0
for index in range(0, len(my_list)):
print(my_list[index])
\
运行结果
21
25
21
23
22
20
元组
#唯一与list 不同的是，元组定义完成后不可修改，常常用于数据的封装
定义:使用小括号(),列表定义使用[]
变量名 = ()
变量名 = tuple()
#当元组只有一个数据，这个数据后面必须带逗号，否则不是元组类型
eg.
my_tuple = (666,)
my_tuple_ = (666)
print(type(my_tuple))
print(type(my_tuple_))
\
运行结果
<class 'tuple'>
<class 'int'>
#元组可以嵌套元组
eg.
my_tuple = ((666,),(666,),666)
print(my_tuple)
\
运行结果
((666,), (666,), 666)
#元组支持的操作
index()
count()
len(元组)
循环遍历
###元组里嵌套的list可以修改###6
eg.
my_tuple = ("omwsxx",["itheima","itcast"])
print(my_tuple)
my_tuple[1][0] = "hahaha"
my_tuple[1][1] = "hohoho"
print(my_tuple)
\
运行结果
('omwsxx', ['itheima', 'itcast'])
('omwsxx', ['hahaha', 'hohoho'])
eg.小练习
my_tuple = ("wx",11,['football','music'])
print(my_tuple.index(11))
print(my_tuple[0])
del my_tuple[2][0]
my_tuple[2].append('coding')
print(my_tuple)
\
运行结果
1
wx
('wx', 11, ['music', 'coding'])
