入门
【qy_01_hello.py】
print("11234")
print("你好")
print("abc")
命令行执行
python qy_01_hello.py
文件命名
不能以数字开头
使用小写字母、数字、下划线
解释器
官方解释器
命令行输入 python 进入python解释器
C:\Users\97301>python
Python 3.11.0rc2 (main, Sep 11 2022, 20:22:52) [MSC v.1933 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("hello 官方解释器")
hello 官方解释器
>>> exit
Use exit() or Ctrl-Z plus Return to exit
>>> exit()
输入exit() 退出解释器
ipython解释器
相比官网的解释器增加了智能提示
安装
pip install ipython
使用
C:\Users\97301>ipython
Python 3.11.0rc2 (main, Sep 11 2022, 20:22:52) [MSC v.1933 64 bit (AMD64)]
Type 'copyright', 'credits' or 'license' for more information
IPython 8.26.0 -- An enhanced Interactive Python. Type '?' for help.
In [1]: print("hello")
hello
In [2]: exit
开发工具
pycharm或者vscode
注释
单行注释: # 空格 注释内容
# 这是单行注释
print("hello")
print("hello world") # 单行注释，前面要空两个格
多行注释
"""
多行注释，使用连续的三个引号
阿斯顿发送到
阿斯蒂芬
"""
print("hello")
代码规范
https://www.cnblogs.com/yugen9/articles/15735737.html
算术运算符
+ 加
- 减
* 乘，还可以用于字符串，计算结果
/ 除
// 取整除
% 取余
** 幂运算
优先级
和数学中的运算符的优先级一致，在 Python 中进行数学计算时，同样也是:
- 先乘除后加减
- 同级运算符是 从左至右 计算。
- 可以使用()调整计算的优先级
以下的算数优先级由高到最低顺序排列
1. **
2. * / % //
3. + -
程序执行原理
变量
定义变量
语法：变量名 = 值
在Python 中，定义变量时是不需要指定变量的类型, 在运行的时候，Python 解释器，会根据赋值语句等号右侧的数据为 自动推导出变量中保存数据的准确类型
【案例】
price = 5.8
num = 20
money = price * num
print(money)
变量类型
数字类型
str 字符串类型
bool 布尔类型 True False
float 小数类型
int 整数类型
非数字类型
字符串
列表
元祖
字典
type函数查看变量类型
>>> a = 12
>>> type(a)
<class 'int'>
>>> type("123")
<class 'str'>
>>> type(True)
<class 'bool'>
不同类型计算
# python中True = 1 False = 0
a = 1 + True
b = 1 + False
print(a) # 2
print(b) # 1
# python中+号可以拼接字符串
c = "123"
d = "456"
print(c+d) # 123456
变量的输入
input函数: 等待用户输入，返回值为字符串
name = input("请输入姓名")
print(name)
类型转换函数
int(x) 将x转换为整数
float(x) 将x转换为浮点数
price = float(input("请输入价格"))
weight = float(input("请输入重量"))
print(price * weight)
格式化变量
%s 字符串
%d 整数 %06d标识输出的整数显示位数，不足的地方使用0补全
%f 浮点数，%.2f表示小数点后只显示2位
%% 输出 %
语法
print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1，变量2...))
【案例】
a = "李华"
print("我叫 %s " % a)
b = 18
print("今年%d岁" % b)
c = 4
print("存款%.2f" % c)
d = 20
print("年级排名%d%%" % d)
print("我叫 %s 今年%d岁" % (a, b))
变量的命名
由字母、数字、下划线组成
不能以数字开头
不能以关键字重名
单词之间用下划线连接、每个单词都使用小写
=号的左右各保留一个空格
关键字
import keyword
print(keyword.kwlist) # 打印所有的关键字
"""
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
"""
if条件判断
if 条件:
条件成立要做的事
注意: 代码的缩进为一个 tab 键，或者4个空格建议使用空格在 Python 开发中，Tab 和空格不要混用!
【案例】
age = 19
if age < 18:
print("未成年")
运算符
== 等于
!= 不等于
> 大于
< 小于
>= 大于等于
<= 小于等于
if else 条件判断
if 条件:
条件成立要做的事
else:
条件不成立要做的事
【案例】
age = 19
if age < 18:
print("未成年")
else:
print("你是大人了")
逻辑运算
and 与
条件1 and 条件2
or 或
条件1 or 条件2
not 非
not 条件
elif
if 条件1:
条件1要做的事
elif 条件2:
条件2要做的事
elif 条件3:
条件3要做的事
else:
条件都不满足要做的事
【案例】
age = 80
if age < 5:
print("幼童")
elif 5 <= age <= 18:
print("少年")
elif 18 < age <= 65:
print("成人")
else:
print("老人")
随机数
import random
num = random.randint(0,10) # 获取[0,10]的随机数 包含0和10
单行代码过长格式化
使用小括号包起来换行
if((player == 1 and computer == 2)
or (player == 2 and computer == 3)
or (player == 3 and computer == 1)):
print("欧耶，电脑弱爆了!")
while循环
# 打印1-10的数字
i = 1
while i <= 10:
print(i)
i += 1
print("i:%d" % i) # 程序执行完毕i依然存在
赋值运算符
= 等于
+= 加等于
-= 减等于
*= 乘等于
/= 除等于
//= 取整除等于
%= 取余等于
**= 幂运算等于
【案例】
a = 22
b = 3
# a /= b
# a **= b
a %= b
print(a)
break和continue
break 表示退出循环
continue 表示结束本次循序，继续下一次循环
二者只对当前所在循环有效
print扩展
在默认情况下，print 函数输出内容之后，会自动在内容末尾增加换行
如果不希望末尾增加换行，可以在print 函数输出内容的后面增加，end=""
其中""中间可以指定 print 函数输出内容之后，继续希望显示的内容
【案例】
print("*",end="")
print("*",end="1234")
转义字符
\t 制表符
\n 换行
\\ 反斜杠
\' 单引号
\r 回车
函数
函数定义
def 函数名():
函数内部代码
函数名 命名规则和变量命名规则一致
可以由 字母、下划线 和 数字 组成不能以数字开头
不能与关键字重名
函数必须先定义再使用！！
【案例】
# 定义函数
def say_hello():
print("hello")
say_hello() # 调用函数
ctrl+q函数文档注释
在开发中，如果希望给函数添加注释，应该在 定义函数 的下方，使用 连续的三对引号
在 连续的三对引号 之间编写对函数的说明文字在 函数调用 位置，光标放在函数名上 可以查看函数的说明信息
注意:因为 函数体相对比较独立，函数定义的上方，应该和其他代码(包括注释)保留两个空行 !!!
【案例】
def say_hello():
"""
打招呼函数
"""
print("hello")
say_hello()
函数的参数
在函数名的后面的小括号内部填写
参数多个参数之间使用,分隔
形参:定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用
实参:调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的
【案例】
def sum_fn(num1, num2):
print(num1 + num2)
sum_fn(1, 2) # 3
函数的返回值
使用return关键字来返回结果
【案例】
def sum_fn(num1, num2):
return num1 + num2
result = sum_fn(1, 2)
print(result) # 3
函数注释
def sum_fn(num1, num2):
"""数字求和
:param num1: 数字1
:param num2: 数字2
:return: 求和结果
"""
return num1 + num2
模块
模块 就好比是 工具包，要想使用这个工具包中的工具，就需要 导入import 这个模块
每一个以扩展名py结尾的Python 源代码文件都是一个 模块
在模块中定义的 全局变量、函数 都是模块能够提供给外界直接使用的工具
案例
【utils.py】
def add(a, b):
return a + b
def subtract(a, b):
return a - b
title = "程序员青阳"
【test_utils.py】
import utils
print(utils.add(1, 2))
print(utils.subtract(4, 2))
print(utils.title)
模块名也是一个标识符
- 标示符可以由 字母、下划线 和 数字 组成，不能以数字开头不能与关键字重名
- 注意: 如果在给Python 文件起名时，以数字开头是无法在Pycharm 中通过导入这个模块的
pyc文件(了解)
C是compiled编译过 的意思
操作步骤
1. 浏览程序目录会发现一个pycache_的目录
2.目录下会有一个hm_18_分隔线模块.cpython-35.pyc文件，(cpython-35 表示Python 解释器的版本3.这个 pyc 文件是由 Python 解释器将 模块的源码 转换为 字节码
。(Python 这样保存 字节码 是作为一种启动 速度的优化
字节码
Python 在解释源程序时是分成两个步骤的
1.首先处理源代码，编译 生成一个二进制 字节码
2.再对 字节码 进行处理，才会生成 CPU 能够识别的 机器码
有了模块的字节码文件之后，下一次运行程序时，如果在 上次保存字节码之后 没有修改过源代码Python 将会加载.pyc文件并跳过编译这个步骤
当Python)重编译时，它会自动检查源文件和字节码文件的时间截如果你又修改了源代码,，下次程序运行时，字节码将自动重新创建
列表
循环遍历列表
name_list = ["张三", "李四","阿发","张三"]
for name in name_list:
print(name)
元祖
Tuple(元组)与列表类似，元组 表示多个元素组成的序列，不同之处在于元组的元素不能修改。
元组 在Python 开发中，有特定的应用场景,用于存储 一串 信息，数据 之间使用，分隔。
元组用()定义
元组的 索引从 8 开始，索引 就是数据在 元组 中的位置编号
【案例】
info_tuple = (1,2,3)
empty_tuple = ()
one_tuple = (1,) # 元组中 只包含一个元素 时，需要 在元素后面添加逗号
print(info_tuple)
print(empty_tuple)
print(one_tuple)
元祖的常用操作和列表类似，可以参考列表的图练习
循环遍历元祖
和列表一样
info_tuple = (1,2,3,1)
for i in info_tuple:
print(i)
在 Python中，可以使用for循环遍历所有非数字型类型的变量:列表、元组、字典 以及 字符串
提示: 在实际开发中，除非 能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多
应用场景
尽管可以使用 for in 遍历 元组
但是在开发中，更多的应用场景是:
函数的 参数 和 返回值，一个函数可以接收 任意多个参数，或者 一次返回多个数据
格式化字符串后面的()本质上就是一个元组让列表不可以被修改，以保护数据安全
元祖和列表之间的转换
list(元祖) 将元祖转列表
tuple(列表) 将列表转元祖
nameList = ["1","2","3","4","5","6","7","8","9"]
print(tuple(nameList))
tupleList = ("a","b","c","d","e","f","g","h")
print(list(tupleList))
字典
dictionary(字典)是除列表以外Python 之中 最灵活 的数据类型字典同样可以用来 存储多个数据,通常用于存储 描述一个 物体 的相关信息
列表 是 有序 的对象集合
字典 是 无序 的对象集合
字典用 {} 定义
字典使用 键值对 存储数据，键值对之间使用,分隔
键 key 是索引
值 value 是数据
键 和 值 之间使用:分隔
键必须是唯一的
值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组
student = {"name":"张三","age":18,"gender":"男"}
print(student)
相关api
len(字典) 获取字典的 键值对数量
字典.keys() 所有 key 列表
字典.values() 所有 value 列表
字典.items() 所有(key,value)元组列表
字典[key] 可以从字典中取值，key 不存在会报错
字典.get(key) 可以从字典中取值，key 不存在不会报错
del 字典[key] 删除指定键值对，key 不存在会报错
字典.pop(key) 删除指定键值对，key 不存在会报错
字典.popitem() 随机删除一个键值对
字典.clear() 清空字典
字典[key] = value 如果 key 存在，修改数据如果 key 不存，新建键值对
字典.setdefault(key, value) 如果 key 存在，不会修改数据如果 key 不存在，新建键值对
字典.update(字典2) 将字典 2 的数据合并到字典
【案例】
student = {"name":"张三","age":18,"gender":"男"}
other = {"hobby": ["吃饭","睡觉"], "phone": "12341234"}
print(student)
print(len(student))
print(student.keys())
print(student.values())
print(student.items())
print(student["name"])
print(student.get("name"))
# del student["name"]
# student.pop("name")
# student.popitem()
# student.clear()
# student["address"] = "北京"
student.update(other)
print(student)
循环遍历(了解)
遍历 就是 依次 从 字典 中获取所有键值对
student = {"name":"张三","age":18,"gender":"男"}
for key in student:
print(student[key])
尽管可以使用 for in 遍历 字典
但是在开发中，更多的应用场景是:
使用 多个键值对,存储 描述一个 物体 的相关信息 --描述更复杂的数据信息
将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理
字符串API
字符串 就是 一串字符，是编程语言中表示文本的数据类型在 Python 中可以使用 一对双引号”或者 一对单引号’定义一个字符串.
虽然可以使用"或者'做字符串的转义，但在实际开发中:如果字符串内部需要使用”，可以使用’定义字符串,如果字符串内部需要使用’，可以使用”定义字符串
可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0开始也可以使用 for循环遍历 字符串中每一个字符
大多数编程语言都是用”来定义字符串
len(字符串) 获取字符串的长度
字符串.count(字符) 字符在字符串中出现的次数
字符串[索引] 取出指定索引的字符
字符串.index(字符串) 获取字符第一次出现的下标
判断类型
string.isspace() 如果 string 中只包含空格，则返回 True
string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True
string.isalpha() 如果string至少有一个字符并且所有字符都是字母则返回True
string.isdecimal() 如果string只包含数字则返回True，全角数字
string.isdigit() 如果string只包含数字则返回True，全角数字
string.isnumeric() 如果string只包含数字则返回True 全角数字，汉字数字
string.istitle() 如果 string 是标题化的(每个单词的首字母大写)则返回 True
string.islower() 如果string中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写 则返回True
string.isupper() 如果string中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写 则返回True
查找和替换
string.startswith(str) 检查字符串是否是以 str 开头，是则返回 True
string.endswith(str) 检查字符串是否是以 str 结尾，是则返回 True
string.find(str, start=0.end=len(string)) 检测 str 是否包含在 string 中，如果 start 和 end指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返-1
string.rfnd(str, start=0,end=len(string)) 类似于 find 函数，不过是从右边开始查找
string.index(str,start=0,end=len(string)) 跟 find 方法类似，只不过如果 str 不在 string 会报错
string.rindex(str,start=0,end-len(string)) 类似于 index方法，不过是从右边开始
string.replace(old str,new_str,num=string.count(old)) 把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次
大小写转换
string.capitalize() 把字符串的第一个字符大写
string.title() 把字符串的每个单词首字母大写
string.lower() 转换 string 中所有大写字符为小写
string.upper() 转换 string 中所有大写字符为大写
string.swapcase() 翻转 string 中的大小写
文本对齐
string.ljust(width) 返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串
string.rjust(width) 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串
string.center(width) 返回一个原字符串居中，并使用空格填充至长度 width 的新字符串
去除空白字符串
string.lstrip() 截掉 string 左边(开始)的空白字符
string.rstrip() 截掉 string 右边(末尾)的空白字符
string.strip() 截掉 string 左右两边的空白字符
拆分和连接
string.partition(str) 把字符串 string 分成一个3元素的元组(str前面,str,str后面)
string.rpartition(str) 类似于 partition()函数，不过是从右边开始查找
string.split(str="",num) 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1个子字符串，str 默认包含 \r,t,\n'和空格
string.splitlines() 按照行(\r,\n,\r\n)分隔，返回一个包含各行作为元素的列表
string.join(seq) 以 string 作为分隔符，将 seq中所有的元素(的字符串表示)合并为一个新的字符串
字符串切片
切片练习题
1.截取从2~5 位置 的字符串
2.截取从 2-末尾 的字符串
3.截取从 开始 ~5 位置 的字符串
4.截取完整的字符串
5.从开始位置，每隔一个字符截取字符串
6.从索引 1开始，每隔一个取一个截取
7.从2~末尾-1的字符串
8.截取字符串末尾两个字符
9.字符串的逆序(面试题)
公共方法
内置函数
len(item) 计算容器中元素个数
del(item) 删除变量
max(item) 返回容器中元素最大值
min(item) 返回容器中元素最小值
cmp(item1,item2) 比较两个值，-1小于/0 相等/1 大于
注意： 字符串 比较符合以下规则:”0”<”A”<”a”
切片
运算符
完整的for方法
变量的进阶
变量的引用
变量 和 数据 都是保存在 内存 中的
在 Python 中函数的 参数传递 以及 返回值 都是靠 引用 传递的
变量 和 数据 是分开存储的
数据 保存在内存中的一个位置
变量 中保存着数据在内存中的地址
变量 中 记录数据的地址，就叫做 引用
使用 id()函数可以查看变量中保存数据所在的 内存地址
注意:如果变量已经被定义，当给一个变量赋值的时候，本质上是修改了数据的引用
变量 不再 对之前的数据引用
变量 改为 对新赋值的数据引用
函数的参数和返回值
可变和不可变类型
注意：字典的key只能使用不可变类型
哈希
局部变量和全局变量
局部变量 是在 函数内部 定义的变量，只能在函数内部使用
全局变量 是在 函数外部定义 的变量(没有定义在某一个函数内)，所有函数 内部 都可以使用这个变量
提示:在其他的开发语言中，大多不推荐使用全局变量–可变范围太大，导致程序不
好维护!
局部变量 是在 函数内部 定义的变量，只能在函数内部使用函数执行结束后，
函数内部的局部变量，会被系统回收
不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
注意:函数执行时，需要处理变量时 会:
- 首先 查找 函数内部 是否存在 指定名称 的局部变量，如果有，直接使用
- 如果没有，查找 函数外部 是否存在 指定名称 的全局变量，如果有，直接使用
- 如果还没有，程序报错!
- 函数不能直接修改全局变量的值，要修改的话需要加上global关键字
- 全角变量的命名建议以 g_开头或者 gl_前缀,具体以开发团队要求为准
num = 1
def test1():
global num
num = 2
print(num) # 2
def test2():
num = 3
print(num) # 3
test1()
test2()
print(num) # 2
函数的参数和返回值
在程序开发中，希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
返回值 是函数 完成工作后，最后 给调用者的一个结果
在函数中使用return 关键字可以返回结果调用函数一方
可以 使用变量 来 接收 函数的返回结果
【案例】
def add(a,b):
sum = a+b
return a,b,sum # 返回一个元祖 ()可以省略
# 如果函数返回的类型是元组，同时希望单独的处理元组中的元素可以使用多个变量，一次接收函数的返回结果
# 注意:使用多个变量接收结果时，变量的个数应该和元组中元素的个数保持一
a,b,sum = add(1,2)
print(a)
print(b)
print(sum)
【利用元祖交换两个变量】
c = 1
d = 2
c,d = d,c
print(c)
print(d)
不可变和可变参数
问题1:在函数内部，针对参数使用 赋值语句，会不会影响调用函数时传递的 实参变量? –不会!
无论传递的参数是 可变 还是 不可变，只要 针对参数 使用 赋值语句，会在 函数内部 修改 局部变量的引用，不会影响到 外部变量的引用
g_name = "tom"
g_num_list = [5,6,7,8,9]
def demo(name,num_list):
name = "jerry"
num_list = [1,2,3,4,5]
print(name) # "jerry"
print(num_list) # [1,2,3,4,5]
demo(g_name,g_num_list)
print(g_name) # "tom"
print(g_num_list) # [5,6,7,8,9]
问题2:如果传递的参数是 可变类型，在函数内部，使用 方法 修改了数据的内容，同样会影响到外部的数据
g_num_list = [5,6,7,8,9]
def test(num_list):
num_list.extend(["a","b","c"])
print(num_list) # [5, 6, 7, 8, 9, 'a', 'b', 'c']
test(g_num_list)
print(g_num_list) # [5, 6, 7, 8, 9, 'a', 'b', 'c']
在 python 中，列表调用+=本质上是在执行列表的extend 方法，不会修改变量的引用
缺省参数
定义函数时，可以给 某个参数 指定一个默认值，具有默认值的参数就叫做 缺省参数
调用函数时，如果没有传入 缺省参数 的值，则在函数内部使用定义函数时指定的 参数
默认值函数的缺省参数，将常见的值设置为参数的缺省值，从而 简化函数的调用
对列表排序的方法
g_num_list = [5,6,7,8,9]
g_num_list.sort() # 缺省参数升序
g_num_list.sort(reverse=True) # 有参数则降序
print(g_num_list)
指定函数的缺省参数
def print_info(name,gender = True):
gender_txt = "女生"
if gender:
gender_txt = "男生"
print("姓名 %s,性别 %s" % (name,gender_txt))
print_info("张三") # 姓名 张三,性别 男生
print_info("李四",False) # 姓名 李四,性别 女生
多值参数(了解)
