一、导学

  1. Pthon语言基础入门
  2. Pthon语言高阶加强
  3. 大数据分析PySpark

二、 初识Python

  1. 你好Python程序
print("Hello World!!")>>Hello World!!

输入的双引号和括号为英文字符

三、 Python基础语法

(一) 字面量

1. 定义:在代码中,被写下来固定的,称之为字面量。

2. 常用的6种值的类型

类型

描述

说明
数字(Number)

支持(4种子类型)

  • 整数(int)
  • 浮点数(float)
  • 复数(complex)
  • 布尔(bool)
  • 整数(int),如:10、-10
  • 浮点数(float),如:13.14、-13.14
  • 复数(complex),如:4+3j,以j为结尾表示复数
  • 布尔(bool),表述现实生活中的真假,即True本质为数字1、False本质为数字0
字符串(String)描述文本的一种数据类型字符串(string)由任意数量的字符组成
列表(List)有序的可变序列Python中使用最频繁的数据类型,可有序记录一堆数据
元组(Tuple)有序的不可变序列可有序记录一堆不可变的Python数据集合
集合(Set)无序不重复集合可无序记录一堆不重复的Python数据集合
字典(Dictionary)无序Key-Value集合可无序记录一堆Key-Value型的Python数据集合

3. 字符串

!Python中,字符串需要用双引号包围;

!被双引号包围的都是字符串

66613.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 - 10print( "买了冰淇淋花费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 )>> >> >> 

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 )>>  11>>  13.14
# 将字符串类型   ->  数字类型num = int( "11" )print( type( num ) , num )num2 = float( "13.14" )print( type( float ) , num2 )>>  11>>  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 )>>  11.0# 浮点数 -> 整数int_num = int( 13.14 )print( type( int_num ) , int_num )>>  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) )>> >> >> 

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 = 11num2 = 11.345print( "数字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 = 2006stock_price = 19.99print( 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中的类型是:

$练习:

(九)数据输入

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>> 你的银行卡密码的类型是: 

$练习:

四、 Python判断语句

(一) 布尔类型和比较运算符

1. 布尔类型:判断结果

True:表示真(是、肯定)

False:表示假(否、否定)

# 定义变量存储布尔类型的数据bool_1 = Truebool_2 = Falseprint( f"bool_1变量的内容是:{ bool_1 },类型为:{ type( bool_1 ) }" )print( f"bool_2变量的内容是:{ bool_2 },类型为:{ type( bool_2 ) }" )>> bool_1变量的内容是:True,类型为:>> bool_2变量的内容是:False,类型为:

2. 比较运算和比较运算符:

==、!=、>、=、<=

(二) if语句的基本格式

1. if语句基本格式:

if 要判断的条件:

条件成立时,要做的事情

!首行缩进确定代码块归属

age = 30if age >= 18:    print( "我已经成年了。" )    print( f"已经{ age }岁了啊!" )print( "时间过得真快啊!" )>> 我已经成年了。>> 已经30岁了啊!>> 时间过得真快啊!

# 判断语句的结果必须为布尔类型的True或False

True会执行if内的代码语句

False则不会执行

age = 10if 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  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 randomnum = 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,其类型是

(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 = 5000000name = Nonedef 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(类)的成员,则称函数为方法。

编号关键字使用方法作用
1index列表.index(元素)查找指定元素在列表中的下标,找不到则报错ValueError
2lenlen(列表)统计容器中有多少元素
3count列表.count(元素)统计此元素在列表中出现的次数
4deldel 列表[下标]删除列表指定的下标元素
5pop列表.pop[下标]删除列表指定的下标元素
6remove列表.remove(元素)从前向后,删除此元素的第一个匹配项
7append列表.append(元素)向列表中追加一个元素
8extend列表.extend(容器)将数据容器中的内容依次取出,追加到列表尾部
9insert列表.insert(下标,元素)在指定下标处,插入指定的元素
10clear

列表.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 + 1print(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. 元组的操作(方法)

编号关键字使用方法作用
1indexindex()查找指定数据在元组中的下标,找不到则报错
2lenlen(元组)统计元组内有多少元素
3countcount()

统计某个数据在元组中出现的次数

! 不可修改元组内容,否则直接报错

! 可修改元组内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字符串[下标]根据下标索引取出特定位置字符
2index字符串.index(字符串)查找给定字符的第一个匹配项的下标
3replace字符串.replace(字符串1,字符串2)

将字符串内的全部字符串1,替换为字符串2

!不会改变原字符串,而是得到一个新的字符串

4split字符串.split(字符串)

按照给定字符串,对字符串进行分割

!不会改变原字符串,而是得到一个新的列表

5strip

字符串.strip()

字符串.strip(字符串)

移除首尾的空格和换行符或指定字符串
6

count

字符串.count(字符串)统计字符串内某字符串的出现次数
7lenlen(字符串)统计字符串的字符个数

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 = -9S1 = S.replace("来", "")S2 = S1.split(",")print(S2)new_S1 = S2[0][9:4:-1]print(new_S1)

(七) 数据容器:set(集合)

1. 集合的基本语法

# 定义集合字面量

(元素,元素,……,元素)

# 定义集合变量

变量名称 = {元素,元素,……,元素}

# 定义空集合

变量名称 = set()

! 去重且无序,无法保证顺序与创建的时候一致

! 不支持:下标索引访问,因此不支持while循环

补充:

定义:

列表[] 可修改、支持重复元素且有序

元组() 不可修改、支持重复元素且有序

字符串“” 不可修改、支持重复元素且有序

集合{} 可修改、不支持重复元素、无序

2. 集合的常用功能

编号关键字使用方法作用
1add集合.add(元素)集合内添加一个元素
2remove集合.remove(元素)移除集合内指定的元素
3pop集合.pop()从集合中随机取出一个元素
4clear集合.clear()将集合清空
5difference集合1.difference(集合2)

得到一个新集合,内含2个集合的差集

原有的2个集合内容不变

6update集合1.difference_update(集合2)

在集合1中,删除集合2中存在的元素

集合1被修改,集合2不变

7union集合1.union(集合2)得到1个新集合,内含2个集合的全部元素原有的2个集合内容不变
8lenlen(集合)得到一个整数,记录了集合的元素数量

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添加或更新键值对
3pop字典.pop(Key)取出Key对应的Value并在字典内删除此Key的键值对
4clear字典.clear()清空字典
5keys字典.keys()获取字典的全部Key,可用于for循环遍历字典
6lenlen(字典)计算字典内的元素数量

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]["工资"] + 1000print(D)

扩展:数据容器的对比总结

列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意任意仅字符任意

Key:除字典外任意类型

Value:任意类型

下标索引××
重复元素××
可修改性××
数据有序×××
使用场景可修改、可重复的一批数据的记录不可修改、可重复的一批数据的记录一串字符的记录不可重复的数据记录以Key检索Value的数据记录

(九) 数据容器的通用操作

序号功能描述
1for循环遍历容器(字典是遍历key)
2max()容器内最大元素
3min()容器内最小元素
4len()容器内元素个数
5list()转换为列表
6tuple()转换为元组
7str()转换为字符串
8set()转换为集合
9sorted(序列,[reverse = True])

排序,得到一个排好序的列表

reverse = True表示“降序”

(十)综合案例

# 幸运数字6:# 1. 输入任意数字,如数字8,生成nums列表,元素值为1-8,#  2. 从中选取幸运数字(能被6整除)移动到新列表lucky# 3. 打印nums和luckyn = int(input("请输入您所想的数字:"))i = 1j = 0nums = list()lucky = list()print(n)while i <= n:    nums.append(i)    i = i + 1print(f"nums列表为:{nums}")for j in nums:    if j % 6 == 0:        lucky.append(j)    j = j + 1print(f"lucky列表为:{lucky}")
# 列表嵌套:# 3个教室[[],[],[]]# 8名讲师['A','B','C','D','E','F','G','H']# 随机分配import randomclassroom = [[],[],[]]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,2x,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. 文件的基本操作函数

编号关键字使用方法作用
1open文件对象 = open(file,mode,encoding)打开文件获得指定文件对象
2read文件对象.read(num)

读取指定长度字节

不指定num读取文件全部

3readline文件对象.readline()读取一行
4readlines文件对象.readline()读取全部行,得到列表
5forfor line in 文件对象for循环文件行,一次循环得到一行数据
6close文件对象.close()关闭文件对象
7with openwith open() as f通过with open语法打开文件,可以自动关闭

! 读取文件后,要用进行关闭,否则文件一直被占用

$练习:

word = open('D:\Desktop\word.txt', 'r', encoding="utf-8")L = word.readlines()num = 0print(L)for i in L:    num = num + i.count("itheima")print(num)

(三) 文件的写入

1. 写操作快速入门:

(1) 使用open的“w”模式进行写入

(2) 文件写入:f.write()

(3) 内容刷新:f.flush()

# 打开文件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. 注意事项

  • a模式,文件不存在,不会创建文件
  • a模式,文件存在,会在最后追加写入文件

(五) 综合案例

十、 Pyhon异常、模块与包

(一) 了解异常

1. 异常

  • 程序运行的过程中出现了错误

2. bug

  • bug就是指异常的意思,因为历史是因为小虫子导致计算机失灵的案例,所以延续至今,bug就代表软件出现错误

(二) 异常的捕获方法

1. 程序出现bug后的情况

  • 程序因为一个bug停止运行
  • 对bug进行提醒·,整个程序继续运行

2. 为什么要捕获异常?

  • 在可能发生异常的方法,进行捕获,当出现异常时,提供解决方式,而不是任由其导致程序无法运行
  • 作用:提前假设某处会出现异常,做好提前准备,当真的出现异常的时候,可以有后续手段

(三) 异常综合案例

(四) Pyhton模块

(五) Python包

(六) 安装第三类Python包