一、导学
- Pthon语言基础入门
- Pthon语言高阶加强
- 大数据分析PySpark
二、 初识Python
- 你好Python程序
print("Hello World!!")
>>Hello World!!
!输入的双引号和括号为英文字符
三、 Python基础语法
(一) 字面量
1. 定义:在代码中,被写下来的固定的值,称之为字面量。
2. 常用的6种值的类型
类型 | 描述 |
说明 |
数字(Number) | 支持(4种子类型)
|
|
字符串(String) | 描述文本的一种数据类型 | 字符串(string)由任意数量的字符组成 |
列表(List) | 有序的可变序列 | Python中使用最频繁的数据类型,可有序记录一堆数据 |
元组(Tuple) | 有序的不可变序列 | 可有序记录一堆不可变的Python数据集合 |
集合(Set) | 无序不重复集合 | 可无序记录一堆不重复的Python数据集合 |
字典(Dictionary) | 无序Key-Value集合 | 可无序记录一堆Key-Value型的Python数据集合 |
3. 字符串
!Python中,字符串需要用双引号包围;
!被双引号包围的都是字符串
666
13.14
"黑马程序员"
print( 666 )
print( 13.14 )
print( "黑马程序员" )
>>666
>>13.14
>>"黑马程序员"
(二) 注释
1. 单行注释
# 我是单行注释
print( "黑马程序员" )
!规范:#号和注释内容一般建议以一个空格隔开
2. 多行注释
"""
我是多行注释
666
13.14
"黑马程序员"
"""
print( 666 )
print( 13.14 )
print( "黑马程序员" )
(三) 变量
1. 定义:程序运行时,能储存计算结果或表示值的抽象概念。
简单的说,变量就是在程序运行时,记录数据用的
2.定义格式:
变量名称 = 变量的值
# 定义变量
money = 5000
# print输出变量
print( " 钱包还有:" , money )
>> 钱包还有: 5000
# 买了东西,花费10元
money = money - 10
print( "买了冰淇淋花费10元,还剩余:" , money , "元" )
>>买了冰淇淋花费10元,还剩余: 4990 元
!变量值可变
$练习:
(四) 数据类型
1. type()语句【具有返回值】
1)语法:
type(被查看类型的数据)
2)使用方法:
a = type( 666 )
print( a )
print( type( 13.14 ) )
name = "黑马程序员"
name_type = type( name )
print( name_type )
>> <class 'int'>
>> <class 'float'>
>> <class 'str'>
2. 变量无类型,查看变量的类型实际上查看的是变量存储数据的类型
!字符串变量:不是字符串是变量,而是变量存储了字符串
(五) 数据类型转换
1. 常见的转换语句
语句(函数) | 说明 |
int( x ) | 将x转换为一个整数 |
float( x ) | 将x转换为一个浮点数 |
str( x ) | 将对象x转换为字符串 |
!此三种语句具有返回值
# 将数字类型 -> 字符串类型
num_str = str( 11 )
print( type( num_str ) , num_str )
float_str = str( 13.14 )
print( type( float_str ) , float_str )
>> <class 'str'> 11
>> <class 'str'> 13.14
# 将字符串类型 -> 数字类型
num = int( "11" )
print( type( num ) , num )
num2 = float( "13.14" )
print( type( float ) , num2 )
>> <class 'int'> 11
>> <class 'float'> 13.14
!想要将字符串转换成数字,必须要求字符串内的内容都是数字
num3 = int ( "黑马程序员" )
print( type( num3 ) , num3 )
>> ValueError: invalid literal for int() with base 10: '黑马程序员'
!浮点数转整数会丢失精度
# 整数 -> 浮点数
float_num = float( 11 )
print( type( float_num ) , float_num )
>> <class 'float'> 11.0
# 浮点数 -> 整数
int_num = int( 13.14 )
print( type( int_num ) , int_num )
>> <class 'int'> 13
(六)标识符
1. 定义:用户在编程时所用的一系列名字,用于给变量、类、方法等命名。
2. 命名规则:
内容限定(英文,中文,数字,下划线_)
!数字不可开头
大小写敏感
不可使用关键字
3. 命名规范:
见名知义
下划线命名法
英文字母全小写
(七) 远算符
1. 算术运算符:+、-、*、/、//、%、**(指数)
2. 赋值运算符:=
3. 复合赋值运算符:+=、-=、*=、/=、//=、%=、**=
(八) 字符串扩展
1. 3种定义方式
1)定义形式:
① 单引号定义法:
name = '黑马程序员'
②双引号定义法:
name = "黑马程序员"
③三引号定义法:
name = """黑马程序员"""
*支持换行操作,使用变量接收它,则为字符串;不使用变量接收,则为多行注释
# 单引号定义法,使用单引号进行包围
name = '黑马程序员'
print( type(name) )
# 双引号定义法,写法和多行注释是一样的
name = "黑马程序员"
print( type(name) )
# 三引号定义法,写法和多行注释是一样的
name = """
我是
黑马
程序员
"""
print( type(name) )
>> <class 'str'>
>> <class 'str'>
>> <class 'str'>
2)字符串的引号嵌套
①单引号法,可以内含双引号;
②双引号定义法,可以内含单引号;
②可以使用转义字符(\)来将引号解除效用,变成普通字符串。
# 字符串内,包含双引号
name = '"黑马程序员"'
print( name )
# 字符串内,包含单引号
name = "'黑马程序员'"
print( name )
# 使用转义字符(\)解除引号的效用
name = "\"黑马程序员\""
print( name )
name = '\'黑马程序员\''
print( name )
>> "黑马程序员"
>> '黑马程序员'
>> "黑马程序员"
>> '黑马程序员'
2. 字符串拼接
1)通过+号进行拼接
name = "黑马程序员"
print( "我的名字是:" + name + "我可以教大家IT技能" )
>> 我的名字是:黑马程序员我可以教大家IT技能
!无法和非字符串类型进行拼接
3. 字符串格式化
1)“%占位符”%变量
2)常用占位符
字符串:%s
整数: %d
浮点数:%f
3)数字精度控制
辅助符号“m.n”来控制数据的宽度和精度
m :控制宽度,要求是数字(很少使用),设置的宽度小于数字本身,不生效
.n:控制小数点精度,要求是数字,会进行小数的四舍五入
%5d:表示将整数的宽度控制在5位,如数字11,被设置为5d,就会变成:[空格][空格][空格]11,用三个空格补足宽度
%5.2f:表示将宽度控制为5,将小数点精度设置为2
小数点和小数部分也算入宽度计算。如:对11.345设置为%7.2后,结果是:[空格][空格]11.35。2个空格补足宽度,小数部分限制2位精度,四舍五入为.35
%.2f:表示不限制宽度,只设置小数点精度为2,如11.345设置为%.2f,结果是11.35
num1 = 11
num2 = 11.345
print( "数字11宽度限制5,结果:%5d" % num1 )
print( "数字11宽度限制1,结果:%1d" % num1 )
print( "数字11.345宽度限制7,小数精度2,结果:%7.2f" % num2 )
print( "数字11.345不限制宽度,小数精度2,结果:%.2f" % num2 )
>> 数字11宽度限制5,结果: 11 # 宽度5,补了3个空格
>> 数字11宽度限制1,结果:11 # 宽度小于数字本身,无影响
>> 数字11.345宽度限制7,小数精度2,结果: 11.35
# 宽度7,补了2个空格,小数精度2,四舍五入后为.35
>> 数字11.345不限制宽度,小数精度2,结果:11.35
# 不限制宽度,小数点后四舍五入后为.35
4)快速写法
语法:
f"内容{变量}"
name = "传智播客"
set_up_year = 2006
stock_price = 19.99
print( f"我是{name},我成立于{set_up_year}。我今天的股票价格是:{stock_price}" )
>> 我是传智播客,我成立于2006。我今天的股票价格是:19.99
# 不做精度控制,原样输出
!以上字符串格式化均可用于表达式格式化
print( "1 * 1的结果是:%d" % ( 1 * 1 ) )
print( f"1 * 1的结果是:{1 * 1}")
print( "字符串在Python中的类型是:%s" % type('字符串') )
>> 1 * 1的结果是:1
>> 1 * 1的结果是:1
>> 字符串在Python中的类型是:<class 'str'>
$练习:
(九)数据输入
1. 语法
input();
2. 使用:
使用input()语句可以从键盘获取输入
使用一个变量接收(存储)input语句获取的键盘输入数据即可
数据输出:print
数据输入:input
print( "请告诉我你是谁?" )
name = input()
print( "GET!!你是:%s" % name )
>> 请告诉我你是谁?
>> XUANseyo
>> GET!!你是:XUANseyo
! input()语句可以在要求使用者输入内容之前,输出提示内容的
name = input( "你是谁?" )
print( "GET!!你是:%s" % name )
>> 你是谁?XUANseyo
>> GET!!你是:XUANseyo
!无论input()输入什么,其都会自动转为字符串类型,我们要自行进行数据类型转换
num = input( "你的银行卡密码是:" )
print( "你的银行卡密码的类型是:" , type( num ) )
>> 你的银行卡密码是:123456
>> 你的银行卡密码的类型是: <class 'str'>
$练习:
四、 Python判断语句
(一) 布尔类型和比较运算符
1. 布尔类型:判断结果
True:表示真(是、肯定)
False:表示假(否、否定)
# 定义变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print( f"bool_1变量的内容是:{ bool_1 },类型为:{ type( bool_1 ) }" )
print( f"bool_2变量的内容是:{ bool_2 },类型为:{ type( bool_2 ) }" )
>> bool_1变量的内容是:True,类型为:<class 'bool'>
>> bool_2变量的内容是:False,类型为:<class 'bool'>
2. 比较运算和比较运算符:
==、!=、>、<、>=、<=
(二) if语句的基本格式
1. if语句基本格式:
if 要判断的条件:
条件成立时,要做的事情
!首行缩进确定代码块归属
age = 30
if age >= 18:
print( "我已经成年了。" )
print( f"已经{ age }岁了啊!" )
print( "时间过得真快啊!" )
>> 我已经成年了。
>> 已经30岁了啊!
>> 时间过得真快啊!
# 判断语句的结果必须为布尔类型的True或False
True会执行if内的代码语句
False则不会执行
age = 10
if age >= 18:
print( "我已经成年了。" )
print( f"已经{ age }岁了啊!" )
print( "时间过得真快啊!" )
>> 时间过得真快啊!
$练习:
(三) if else 语句
1. 基本格式:
if 条件 :
满足条件时要完成的事1
满足条件时要完成的事2
……
else:
不满足条件时要完成的事1
不满足条件时要完成的事2
……
print( "欢迎来到黑马儿童游乐场,儿童免费,成人收费!" )
age = input( "请输入您的年龄:" )
if int(age) >= 18 :
print( "您已成年,游玩需补票10元" )
else :
print( "您未成年,无需补票" )
print( "祝您游玩愉快!!!" )
>> 欢迎来到黑马儿童游乐场,儿童免费,成人收费!
>> 请输入您的年龄:17
>> 您未成年,无需补票
>> 祝您游玩愉快!!!
$练习:
(四) if elif else 语句
1. 基本格式:
if 条件1 :
条件1满足时要完成的事
条件1满足时要完成的事
……
elif 条件2::
条件2满足时要完成的事
条件2满足时要完成的事
……
elif 条件n:
条件n满足时要完成的事
条件n满足时要完成的事
……
else:
所有条件不满足时要完成的事
所有条件不满足时要完成的事
……
print("欢迎来到黑马动物园!!")
height = int(input("请输入你的身高:"))
vip_level = int(input("请输入您的vip级别(1~5):"))
if height < 120 :
print("您的身高小于120cm,可以免费游玩")
elif vip_level > 3 :
print("您的vip级别大于3,可以免费游玩")
else :
print("不好意思,所有条件均不符合,需要购票10元")
print("祝您游玩愉快")
>> 欢迎来到黑马动物园!!
>> 请输入你的身高:150
>> 请输入您的vip级别(1~5):5
>> 您的vip级别大于3,可以免费游玩
>> 祝您游玩愉快
$练习:
(五) 判断语句的嵌套
1. 基本格式
if 条件1 :
满足条件1时要完成的事1
满足条件1时要完成的事2
……
if条件2:
满足条件2做的事情1
满足条件2做的事情2
……
2. 嵌套的关键点:空格缩进
通过空格缩进,来决定语句之间的:层次关系
(六) 实战案例
import random
num = random.randint(1,10)
m = int(input("第一次才得数字:"))
if num == m :
print ("猜对啦!")
else :
if num > m:
print("猜小了!")
else :
print("猜大了!")
m2 = int(input("第二次猜测的数字:"))
if m2 == num:
print("第二次猜对了!")
elif num > m2:
print("第二次猜小了!")
elif num < m2:
print("第二次猜大了")
guess_num = int(input("第三次输入你要猜测的数字:"))
if guess_num == num:
print("第三次猜中了")
else:
print("三次机会用完了,没有猜中。")
五、 Python循环语句
(一) while循环的基本语法
1. 基本格式
while 条件:
条件满足时,做的事情1
条件满足时,做的事情2
…(省略)…
- 只要条件满足,会无限循环执行
- 条件需要布尔类型结果
$练习:
(二) while循环的基础案例
(三) while循环的嵌套应用
1. 基本格式:
while 条件1:
条件1满足时,做的事情1
条件1满足时,做的事情2
…(省略)…
while 条件2:
条件2满足时,做的事情1
条件2满足时,做的事情2
…(省略)…
(四) while循环的嵌套应用
补充:
1. print输出不换行
print("Hello",end=' ')
print("World!",end='')
>> Hello World!
2. 制表符/t
print("学号\t姓名\t语文\t数学\t英语")
print("2022001\t小王\t99\t\t88\t\t0")
print("2022002\t小周\t92\t\t45\t\t93")
print("2022008\t小黄\t77\t\t82\t\t100")
(五) for循环的基础语法
1. 基础语法
for循环就是将“待办事项”逐个完成的循环机制
- while循环的循环条件是自定义,自行控制循环条件
- for循环是一种“轮询”机制,是对一批内容进行逐个处理
!for循环无法定义循环条件,只能从被处理的数据集中,依次取出内容进行处理
1) 基本格式:
for 临时变量 in 待处理的数据集:
循环满足条件时执行的语句
$练习:
2. range语句
1) 功能:获得一个数字序列(可迭代类型的一种)
2) 语法格式:
range(num)
获取一个从0开始,到num结束的数字序列
range(num1,num2)
获取一个从num1开始,到num2结束的数字序列(不含num2本身)
range(num1,num2,step)
获得一个从num1开始,到num2结束的数字序列(不含num2本身)
数字之间的步长,以step为准(step默认为1)
$练习:
3. 变量作用域
(六)for循环的嵌套应用
1. 基本格式:
for 临时变量 in 待处理的数据集:
循环满足条件时执行的语句1
循环满足条件时执行的语句2
……
for 临时变量 in 待处理的数据集:
循环满足条件时执行的语句1
循环满足条件时执行的语句1
$练习:
(七) 循环中断:break和continue
1. continue关键字作用:中断本次循环,直接进入下一次循环【for循环和while循环即可使用】
2. break关键字作用:所在循环永久中断【for循环和while循环即可使用】
(八) 综合案例
六、 Python函数
(一) 函数介绍
1. 函数:是组织好的,可重复使用的,用来实现特定功能的代码段。
eg. len():实现统计长度这一特定功能的代码段。
2. 函数好处:
* 将功能封装在函数内,可随时随地重复利用
* 提高代码的复用性,减少重复代码,提高开发效率
(二) 函数定义
1. 基本语法:
(1) 函数定义
def 函数名 (传入函数):
函数体
return 返回值
(2) 函数调用
函数名(参数)
!参数可省略
!返回值可省略
!函数必须先定义后使用
$练习:
def printWelcome ():
print("欢迎来到黑马程序员!")
print("请出示48小时核酸检测证明!")
printWelcome()
(三) 函数参数
1. 传入参数的功能:在函数调用时,接受外部提供的数据
!参数之间按顺序传入;使用,进行分隔
$练习:
def printWelcome(x):
print("欢迎来到黑马程序员!请出示48小时核酸检测证明!")
if x <= 37.5:
print(f"体温测量中,您的体温是:{x},体温正常,请进!")
else:
print(f"体温测量中,您的体温是{x},需要隔离!")
y = int(input("请输入您的体温:"))
printWelcome(y)
(四) 函数返回值
1. 通过return关键字,可向调用者返回数据
2.. None类型:
(1) None,其类型是<class ’NoneType’>
(2) 无返回值的函数,实际上是返回了None这个字面量
(3) 使用:
- 用于函数返回值中【空】
- 用于if判断【None等同于False】
- 用于声明无内容的变量上
(五) 函数说明文档
1. 函数说明文档:对函数进行说明解释,帮助更好地理解函数
2.. 定义语法:
def func(x,y)
"""
函数说明
:param x:参数x的说明
:param x:参数x的说明
:return:返回值的说明
"""
函数体
return 返回值
(六) 函数嵌套使用
1. 函数嵌套:在一个函数中,调用另一个函数。
2. 执行流程:
函数a中执行到调用函数b的语句,会将b全部执行;完成后,继续执行函数a的剩余内容
(七) 变量的作用域
1. 变量作用域:变量的作用范围
2.. 局部变量:定义在函数体内部的变量,只在函数体内部生效
局部变量作用:在函数体内部,临时保存数据,即当函数调用完成后,销毁局部变量
3. 全局变量:在函数体内外都能生效的变量
4. global关键字:可使函数内部声明变量为全局变量
(八) 综合案例
money = 5000000
name = None
def menu():
name = input("您好!请输入客户姓名:")
print("您好,请问您需要什么服务呢?")
print("输入1:查询余额")
print("输入2:存款")
print("输入3:取款")
n = int(input("请输入功能号:"))
if n == 1:
check(money)
elif n == 2:
x = int(input("请输入您想存入的金额:"))
deposit(x, money)
elif n == 3:
y = int(input("请输入您想取出的金额:"))
withdraw(y, money)
def check(money):
print(f"您好!您的余额为:{money}")
menu()
def deposit(x, money):
money1 = x + money
print(f"您好,存款成功后,您的余额为:{money1}")
menu()
def withdraw(x, money):
money2 = money - x
print(f"您好,取款成功后,您的余额为:{money2}")
menu()
menu()
七、 Python数据容器
(一) 数据容器入门
1. 数据容器:一种可以容纳多份数据的数据类型,容纳的每一份数据称之为一个元素。每一个元素,可以是任意类型的数据,如字符串、数字、布尔等。
2.. 种类:list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)
(二) 数据容器:list(列表)
1. 定义
(1) 基本语法:
# 字面量
[元素1 ,元素2 ,元素3,……]
# 定义变量
变量名称 = [元素1 ,元素2 ,元素3,……]
# 定义空列表
变量名称 = []
变量名称 = list()
(2) 元素:列表中的每个数据
! 列表可以一次存储多个数据,且可以为不同类型,支持嵌套
2. 列表的下标索引
(1) 类型:正向:从前向后,从0开始,依次递增
反向:从后向前,从-1开始,依次递减
(2) 使用:
列表[下标]
! 下标超出范围,则无法取出元素,并且会报错
3. 列表的常用操作(方法)
* 函数:封装的代码单元,可提供特定功能。
如将函数定义为class(类)的成员,则称函数为方法。
编号 | 关键字 | 使用方法 | 作用 |
1 | index | 列表.index(元素) | 查找指定元素在列表中的下标,找不到则报错ValueError |
2 | len | len(列表) | 统计容器中有多少元素 |
3 | count | 列表.count(元素) | 统计此元素在列表中出现的次数 |
4 | del | del 列表[下标] | 删除列表指定的下标元素 |
5 | pop | 列表.pop[下标] | 删除列表指定的下标元素 |
6 | remove | 列表.remove(元素) | 从前向后,删除此元素的第一个匹配项 |
7 | append | 列表.append(元素) | 向列表中追加一个元素 |
8 | extend | 列表.extend(容器) | 将数据容器中的内容依次取出,追加到列表尾部 |
9 | insert | 列表.insert(下标,元素) | 在指定下标处,插入指定的元素 |
10 | clear | 列表.clear() |
清空列表 |
4. 列表的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
$练习:
age = [21, 25, 21, 23, 22, 20]
age.append(31)
print(age)
age.extend([29, 33, 30])
print(age)
x = age[0]
y = age[-1]
print(x, y)
a = age.index(31)
print(a)
(三) list(列表)的遍历
* 遍历:将容器内的元素依次取出,并处理
1. 使用while遍历
- 可以指定循环条件,自行控制
- 可以通过条件控制做到无限循环
- 适用于任何想要循环的场景
2. 使用for遍历
- 不可以指定循环条件,只可以一个个从容器内取出数据
- 理论上不可以无限循环,因为被遍历的容器容量不是无限的
- 适用于遍历数据容器的场景或简单的固定次数循环场景
$练习:
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
l1 = list()
l2 = list()
i = 0
# 取出偶数
while i < len(L):
if L[i] % 2 == 0:
l1 . append(L[i])
i = i + 1
else:
i = i + 1
print(f"通过while循环,从列表:{L},中取出偶数,组成新列表{l1}")
for j in L:
if j % 2 == 0:
l2 . append(j)
print(f"通过for循环,从列表:{L},中取出偶数,组成新列表{l2}")
(四) 数据容器:tuple(元组)
* 元组一旦定义,不可进行修改
1. 元组的定义
(1) 基本语法:
# 字面量
(元素1 ,元素2 ,元素3,……)
# 定义变量
变量名称 =(元素1 ,元素2 ,元素3,……)
# 定义空列表
变量名称 = ()
变量名称 =tuple()
! 元组即使只含有一个数据,这个数据后也要添加,也可进行嵌套
2. 元组的操作(方法)
编号 | 关键字 | 使用方法 | 作用 |
1 | index | index() | 查找指定数据在元组中的下标,找不到则报错 |
2 | len | len(元组) | 统计元组内有多少元素 |
3 | count | count() | 统计某个数据在元组中出现的次数 |
! 不可修改元组内容,否则直接报错
! 可修改元组内list的内容
! 不可以替换元组内list为其他list或其他类型
3. 元组的特点
- 可容纳多个元素
- 可容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可进行增删查改
- 可进行循环
- 不可修改
$练习:
T = ('周杰伦', 11, ['football', 'music'])
a = T.index(11)
n = T[0]
print(a,n)
del T[2][0]
T[2].append('coding')
print(T)
(五) 数据容器:str(字符串)
1. 字符串
字符的容器,一个字符串可以存放任意数量的字符。
2. 字符串的下标(索引)
- 从前向后,下标从0开始
- 从后向前,下标从-1开始
! 字符串是一个无法修改的数据容器
! 如果要修改,则会得到一个新的字符串,旧的字符串是无法修改的
3. 字符串的常用操作
编号 | 关键字 | 使用方法 | 作用 |
1 | 字符串[下标] | 根据下标索引取出特定位置字符 | |
2 | index | 字符串.index(字符串) | 查找给定字符的第一个匹配项的下标 |
3 | replace | 字符串.replace(字符串1,字符串2) | 将字符串内的全部字符串1,替换为字符串2 !不会改变原字符串,而是得到一个新的字符串 |
4 | split | 字符串.split(字符串) | 按照给定字符串,对字符串进行分割 !不会改变原字符串,而是得到一个新的列表 |
5 | strip | 字符串.strip() 字符串.strip(字符串) |
移除首尾的空格和换行符或指定字符串 |
6 | count |
字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
7 | len | len(字符串) | 统计字符串的字符个数 |
4. 字符串的特点
- 只可以存储字符串
- 长度任意
- 支持下标索引
- 允许重复的字符串出现
- 不可以修改
- 支持循环
$练习:
S = "itheima itcast boxuegu"
n = S.count("it")
print(f"字符串{S}中有{n}个it字符")
S1 = S.replace(" ", "|")
print(f"字符串{S},被替换空格后,结果{S1}")
L = S1.split("|")
print(f"字符串{S},按照“|”分割后,得到{L}")
(六) 数据容器的切片
1. 序列
内容连续、有序、可使用下标索引的一类数据容器。(如列表、元组、字符串等)
2. 切片
(序列的常用操作)从一个序列中,取出一个子序列
3. 基本语法
序列[起始下标:结束下标:步长]
* 表示从序列中,从指定位置开始,依次取出指定元素,到指定位置结束,得到一个新序列
* 起始下标表示从何处开始,可以留空,留空视作从头开始
* 结束下标(不含)表示何处结束,可以留空,留空视作截取到结尾
* 步长表示,依次取元素的间隔
- 步长1表示,一个个取元素
- 步长2表示,每次跳过1个元素取
- 步长N表示,每次跳过N-1个元素取
- 步长为负数表示,反向取(注意,起始下标和结束下标也要反向标记)
$练习:
S = "万过薪月,员序程马黑来,nohtyP学"
# 使用“切片”
new_S = S[9:4:-1]
print(new_S)
# 使用字符串常用操作
i = -9
S1 = S.replace("来", "")
S2 = S1.split(",")
print(S2)
new_S1 = S2[0][9:4:-1]
print(new_S1)
(七) 数据容器:set(集合)
1. 集合的基本语法
# 定义集合字面量
(元素,元素,……,元素)
# 定义集合变量
变量名称 = {元素,元素,……,元素}
# 定义空集合
变量名称 = set()
! 去重且无序,无法保证顺序与创建的时候一致
! 不支持:下标索引访问,因此不支持while循环
补充:
定义:
列表[] 可修改、支持重复元素且有序
元组() 不可修改、支持重复元素且有序
字符串“” 不可修改、支持重复元素且有序
集合{} 可修改、不支持重复元素、无序
2. 集合的常用功能
编号 | 关键字 | 使用方法 | 作用 |
1 | add | 集合.add(元素) | 集合内添加一个元素 |
2 | remove | 集合.remove(元素) | 移除集合内指定的元素 |
3 | pop | 集合.pop() | 从集合中随机取出一个元素 |
4 | clear | 集合.clear() | 将集合清空 |
5 | difference | 集合1.difference(集合2) | 得到一个新集合,内含2个集合的差集 原有的2个集合内容不变 |
6 | update | 集合1.difference_update(集合2) | 在集合1中,删除集合2中存在的元素 集合1被修改,集合2不变 |
7 | union | 集合1.union(集合2) | 得到1个新集合,内含2个集合的全部元素原有的2个集合内容不变 |
8 | len | len(集合) | 得到一个整数,记录了集合的元素数量 |
3. 集合的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据(混装)
- 数据是无序存储的(不支持下标存储)
- 不允许重复数据存在
- 可以修改
- 支持for循环,不支持while循环
$练习:
my_list = ['黑马程序员','传智播客','黑马程序员','传智播客','itheima','itcast','itheima','itcast','best']
S = set()
for i in my_list:
S.add(i)
print(f"有列表:{my_list}")
print(f"存入集合后结果:{S}")
(八) 数据容器:dict(字典、映射)
1. 字典的基本语法
# 定义字典字面量
{key:value,key:value,……,key:value}
# 定义字面变量
my_dict = {key:value,key:value,……,key:value}
# 定义空字典
my_dict = {}
my_dict = dict{}
! 每个元素均为键值对,key和value可以为任意类型数据(key不可为字典)
! key不可重复,重复会对原有数据覆盖
! 不可以使用下标索引,但可通过key值取得对应的value,不可使用while循环
! 字典可嵌套
2. 字典的常用操作
编号 | 关键字 | 使用方法 | 作用 |
1 | 字典[Key] | 获取指定Key对应的Value值 | |
2 | 字典[Key] = Value | 添加或更新键值对 | |
3 | pop | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
4 | clear | 字典.clear() | 清空字典 |
5 | keys | 字典.keys() | 获取字典的全部Key,可用于for循环遍历字典 |
6 | len | len(字典) | 计算字典内的元素数量 |
3. 字典的特点
- 可以容纳多个数据
- 可以容纳不同类型的数据(混装)
- 不支持下标索引
- 可以修改
- 支持for循环,不支持while循环
$练习:
D = {
"王力鸿":{"部门":"科技部","工资":3000,"级别":1},
"周婕纶":{"部门":"市场部","工资":5000,"级别":2},
"凌俊杰":{"部门":"市场部","工资":7000,"级别":3},
"张雪有":{"部门":"科技部","工资":4000,"级别":1},
"牛德华":{"部门":"市场部","工资":6000,"级别":2}
}
keys = D.keys()
print(D)
for key in keys:
if D[key]["级别"] == 1:
D[key]["工资"] = D[key]["工资"] + 1000
print(D)
扩展:数据容器的对比总结
列表 | 元组 | 字符串 | 集合 | 字典 | |
元素数量 | 支持多个 | 支持多个 | 支持多个 | 支持多个 | 支持多个 |
元素类型 | 任意 | 任意 | 仅字符 | 任意 | Key:除字典外任意类型 Value:任意类型 |
下标索引 | ✓ | ✓ | ✓ | × | × |
重复元素 | ✓ | ✓ | ✓ | × | × |
可修改性 | ✓ | × | × | ✓ | ✓ |
数据有序 | ✓ | ✓ | × | × | × |
使用场景 | 可修改、可重复的一批数据的记录 | 不可修改、可重复的一批数据的记录 | 一串字符的记录 | 不可重复的数据记录 | 以Key检索Value的数据记录 |
(九) 数据容器的通用操作
序号 | 功能 | 描述 |
1 | for循环 | 遍历容器(字典是遍历key) |
2 | max() | 容器内最大元素 |
3 | min() | 容器内最小元素 |
4 | len() | 容器内元素个数 |
5 | list() | 转换为列表 |
6 | tuple() | 转换为元组 |
7 | str() | 转换为字符串 |
8 | set() | 转换为集合 |
9 | sorted(序列,[reverse = True]) | 排序,得到一个排好序的列表 reverse = True表示“降序” |
(十)综合案例
# 幸运数字6:
# 1. 输入任意数字,如数字8,生成nums列表,元素值为1-8,
# 2. 从中选取幸运数字(能被6整除)移动到新列表lucky
# 3. 打印nums和lucky
n = int(input("请输入您所想的数字:"))
i = 1
j = 0
nums = list()
lucky = list()
print(n)
while i <= n:
nums.append(i)
i = i + 1
print(f"nums列表为:{nums}")
for j in nums:
if j % 6 == 0:
lucky.append(j)
j = j + 1
print(f"lucky列表为:{lucky}")
# 列表嵌套:
# 3个教室[[],[],[]]
# 8名讲师['A','B','C','D','E','F','G','H']
# 随机分配
import random
classroom = [[],[],[]]
teacher = ['A','B','C','D','E','F','G','H']
j = random.randint(0,2)
for i in teacher:
classroom[j].append(i)
j = random.randint(0,2)
print(f"分配后为:{classroom}")
八、 函数进阶
(一) 函数多返回值
- 按照返回值的顺序,写对顺序的多个变量接收即可
- 变量之间用逗号隔开
- 支持不同类型的数据return
def test_return():
return 1,2
x,y = test_return()
print(x)
print(y)
>>1
>>2
(二) 函数的多种传参方式
函数参数种类:根据使用方式不同:分为以下4种
1. 位置参数
- 根据函数定义的参数位置来传递参数
! 传递的参数和定义的参数的顺序及个数必须一致
2. 关键字参数
- 函数调用时通过键值对的形式传递参数
! 函数调用时,如果有位置参数时,位置参数必须在关键字参数的前面,但关键字参数之间不存在先后顺序
3. 缺省参数
- 也称默认参数,用于定义函数,为函数提供默认值,调用函数时可不传该默认参数的值
! 所有位置参数必须出现在默认参数前,包括函数定义和调用
! 函数调用时,如果为缺省参数传值则修改默认参数值,否则使用这个默认值
4. 不定长参数
- 也称可变参数,用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。
! 当调用函数时不确定参数个数时,可以使用不定长参数。
(1) 位置传递
- 传进的所有参数都会被args变量收集,他会根据传进参数的位置合并为一个元组(tuple),args是元组类型,这就是位置传递
def user(*args):
print(args)
user('Belly',20,1)
>>('Belly', 20, 1)
(2) 关键字传递
- 参数是键值对形式,所有键值对都会被kwargs接受,同时根据键值对组成字典
def user(**kwargs):
print(kwargs)
user(name = 'Belly',age = 20,sex = 1)
>>{'name': 'Belly', 'age': 20, 'sex': 1}
(三) 匿名函数
1. 函数作为参数传递
- 函数本身可以作为参数,传入另一个函数中进行使用
- 函数传入的作用在于:传入计算逻辑,而非传入数据
2. lambda匿名函数
(1) 函数定义:
- def关键字:定义带有名称的函数(可以使用名称进行重复使用)
- lambda关键字:定义匿名函数(只可临时使用一次)
(2) lambda基本语法:
lambda 传入参数:函数体(一行代码)
! 函数体只可写一行代码,无法写多行
def test(compute):
result = compute(2,3)
print(result)
test(lambda x,y:x + y)
九、 Python文件操作
(一) 文件的编码
1. 编码
- 编码是一种规则集合,记录了内容和二进制间进行相互转换的逻辑
- 编码有许多种,最常用的是utf-8
2. 使用编码的原因
- 计算机只能识别二进制数,因此要将文件的内容翻译为二进制数,才能保存进计算机内
- 同时也需要编码,将计算机保存的二进制数,反向编译回可识别的内容
(二) 文件的读取
1. 文件的基本操作步骤
- 打开文件
- 读写文件
- 关闭文件
! 可以只读,不写
2. 文件的基本操作函数
编号 | 关键字 | 使用方法 | 作用 |
1 | open | 文件对象 = open(file,mode,encoding) | 打开文件获得指定文件对象 |
2 | read | 文件对象.read(num) | 读取指定长度字节 不指定num读取文件全部 |
3 | readline | 文件对象.readline() | 读取一行 |
4 | readlines | 文件对象.readline() | 读取全部行,得到列表 |
5 | for | for line in 文件对象 | for循环文件行,一次循环得到一行数据 |
6 | close | 文件对象.close() | 关闭文件对象 |
7 | with open | with open() as f | 通过with open语法打开文件,可以自动关闭 |
! 读取文件后,要用进行关闭,否则文件一直被占用
$练习:
word = open('D:\Desktop\word.txt', 'r', encoding="utf-8")
L = word.readlines()
num = 0
print(L)
for i in L:
num = num + i.count("itheima")
print(num)
(三) 文件的写入
1. 写操作快速入门:
(1) 使用open的“w”模式进行写入
(2) 文件写入:f.write()
(3) 内容刷新:f.flush()文章来源:https://www.toymoban.com/news/detail-413023.html
# 打开文件
f = open('D:\Desktop\word.txt','w')
# 写入文件
f.write('hello world!')
# 内容刷新
f.flush()
! 直接调用write,内容并未真正写入文件,而是积攒在程序的内存中,称为缓冲区
! 当调用flush时,文件才会真正写入文件
! 这样避免频繁的操作硬盘,导致效率下降
2. 注意事项:
- w模式,文件不存在,会创建新文件
- w模式,文件存在,会清空原有内容
- close方法,具有flush方法的作用
(四) 文件的追加
1. 追加写入操作的快速入门
(1) 使用open的“a”模式进行写入
(2) 文件写入:f.write()
(3) 内容刷新:f.flush()
# 打开文件
f = open('D:\Desktop\word.txt','a')
# 文件写入
f.write('I like pyhton!')
# 内容刷新
f.flush()
2. 注意事项文章来源地址https://www.toymoban.com/news/detail-413023.html
- a模式,文件不存在,不会创建文件
- a模式,文件存在,会在最后追加写入文件
(五) 综合案例
十、 Pyhon异常、模块与包
(一) 了解异常
1. 异常
- 程序运行的过程中出现了错误
2. bug
- bug就是指异常的意思,因为历史是因为小虫子导致计算机失灵的案例,所以延续至今,bug就代表软件出现错误
(二) 异常的捕获方法
1. 程序出现bug后的情况
- 程序因为一个bug停止运行
- 对bug进行提醒·,整个程序继续运行
2. 为什么要捕获异常?
- 在可能发生异常的方法,进行捕获,当出现异常时,提供解决方式,而不是任由其导致程序无法运行
- 作用:提前假设某处会出现异常,做好提前准备,当真的出现异常的时候,可以有后续手段
(三) 异常综合案例
(四) Pyhton模块
(五) Python包
(六) 安装第三类Python包
到了这里,关于2022黑马Python学习笔记的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!