python 基础（数据类型、运算符、流程控制、推导式、函数等...更新中）

python基础

一、认识Python

1、python起源

Python 的创始人为吉多·范罗苏姆（Guido van Rossum），江湖人称“龟叔”。

1991年，第一个Python解释器诞生，它是用C语言实现的，并能够调用C语言的库文件。

1.1、Python的组成

• Python的语法
• Python的标准内置库
• Python的第三方库
• Python解释器

1.2、解释器

编译器翻译的方式有两种：一个是编译，另外一个是解释。两种方式之间的区别在于翻译时间点的不同。当编译器以解释方式运行的时候，也称之为解释器。

• 编译型语言：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依赖编译器，跨平台性差些。如：C、C++
• 解释型语言：解释型语言编写的程序不进行预先编译，以文本方式存储程序代码，会将代码一句一句直接运行。在发布程序时，看起来省了道编译工序，但是在运行程序的时候，必须先解释再运行

编译型语言和解释型语言对比：

• 速度 —— 编译型语言比解释型语言执行速度快
• 跨平台性 —— 解释型语言比编译型语言跨平台性好

2、Python特点

• Python是完全面向对象的语言
  • 函数、模块、数字、字符串都是对象，在Python中一切皆对象
  • 完全支持继承、多重继承等
• Python拥有一个强大的标准库，Python语言的核心只包含数字、字符串、列表、字典、文本等常见类型和函数，而由Python标准库提供了系统管理、网络通信、文本处理、数据库接口、图形系统、等额外的功能
• Python社区提供了大量的第三方模块，使用方式与标准库类似。它们的功能涵盖科学计算、人工智能、机器学习、Web开发、数据库接口、图形系统多个领域

3、Python的优缺点

3.1、优点

• 简单、易学
• 免费、开源
• 面向对象
• 丰富的库
• 可扩展性

3.2、缺点

• 速度慢：Python程序比Java、C、C++等程序的运行效率都要慢
• 源代码加密困难：不像编译型语言的源程序会被编译成目标程序，Python直接运行源程序，因此对源代码加密比较困难。

二、安装Python

https://blog.csdn.net/weixin_47643553/article/details/108815728

三、第一个Python程序

1、第一个hello world程序

1.1、Python源程序的基本概念

• Python源程序就是一个特殊格式的文本文件，可以使用任意文本编辑软件做Python的开发
• Python程序的文件扩展名通常都是.py

1.2、编写程序

• 新建目录
• 新建.py文件
• 编辑.py文件

print("hello world")
print("hello python")

• 在终端中输入以下命令执行xxx.py

python xxx.py

四、pycharm安装

此处安装省略

五、Python的数据类型

Python六个标准的数据类型

• number（数字）
• string（字符串）
• list（列表）
• tuple（元组）
• set（集合）
• dictionary（字典）

5.1、Python变量的声明与使用

• 变量：作用是存储程序运行中的值，变量的值在程序运行中是可以变化的，变量必须先声明再使用。
• Python变量的声明：变量名=值
  • 在Python中变量是没有数据类型的，变量的数据类型取决于赋值的类型，这与其他语言不一样。

# 声明一个变量num1，赋值为整数8
num1 = 8
# 查看num1的类型
print(type(num1))
# 使用变量num1
print(num1)

# 声明一个变量str1，赋值为字符串hello
str1 = "hello"
# 查看str1的类型
print(type(str1))
# 输出变量str1
print(str1)
# 多个变量同时定义
num2,str2 = 1,"你好"
print(num2,str2)

• 常量：Python没有常量的概念，Python程序一般通过约定俗成的变量名全大写的形式表示这是一个常量。

# Java中常量举例：声明常量PRICE，赋值为10，声明后这个常量的值就固定为10，不能再对它赋值
final int PRICE = 10;

# 如果Python中要定义常量，如下：
PI = 3.14
MONTH = 12

5.2、数值型

Python中的数值型包括：int（整型）、float（浮点型）、complex（复数），在Python2中还有long（长整型）

5.2.1、int

int（整型）：表示一个整数，包括正整数、负整数

num1 = 100
print(type(num1))
<class 'int'>

type()函数：type函数的作用是查询变量的数据类型

5.2.2、float

float（浮点型）：表示一个小数，但在计算机中float只能表示一个近似值，不能表示精确值，这是因为浮点数的机制决定的（浮点数必须包含一个小数点，否则会被当作int类型处理）

a = 3.11
b = 1.5
print(a-b)
# 1.6099999999999999

如果要表示精确值，可以使用Decimal对象来实现

# 通过实例化Decimal对象来表示精确小数
from decimal import Decimal
print(Decimal("3.11")-Decimal("1.5"))
# 1.61

5.2.3、其他进制的表示与相互转换

常见的进制：二进制、八进制、十进制、十六进制等

• 二进制（Binary）
  • 由0，1组成，逢二进一
  • 二进制的声明：在数字前加0b表示二进制

# 声明一个变量a，赋值为二进制1001
a = 0b1001
# 输出a的值，输出的是十进制9
print(a)

• 八进制（Octal）
  • 由0，1，…，7组成，逢八进一
  • 八进制的声明：0o

# 声明一个变量a
a = 0o11
# 输出a
print(a)

• 十进制（Decimal）

  • 十进制的声明：Python中默认的数值就是十进制的

• 十六进制（Hexadecimal）

  • 十六进制的声明：在数字前加0x表示十六进制

# 十六进制
a = 0x000F
# 输出a的值，输出的是十进制15
print(a)

• 进制转换函数

# **进制转换函数**
# - bin()：把十进制转成二进制
# - oct()：把十进制转成八进制
# - hex()：把十进制转成十六进制
# - int(x,base=y)：表示把y进制的字符串x转换成十进制的整数
# - 举例：
print(bin(10)) # 十进制转换为二进制
# 0b1010
print(oct(10)) # 十进制转换为八进制
# 0o12
print(hex(17)) # 十进制转换为十六进制
# 0x11
print(int("1000",base=2))#表示把2进制的字符串“1000”转换成十进制的整数
# 8
print(int("1002",base=2))#思考：输出是什么？

5.3、字符串-str

5.3.1、字符串的声明

字符串用引号来声明，字符串是有序的一串字符。

# 字符串的声明

str1 = "hello"
str2 = "world"

print("str1",type(str1),len(str1))
print(str1)
print("str2",type(str2),len(str2))
print(str2)
print(str1+" "+str2)

5.3.2、字符串的切片

字符串是有序的，字符串中的每个字符是有索引下标的，字符串的索引有两种：

• 正序索引：0开始，从左到右
• 倒序索引：-1开始，从右到左

字符串切片语法：

1、str[start : end : step]

2、str[index]

# 字符串的切片

str3 = "hello world"

# 步长为正
# 取当前位置的值
print(str3[1])
# 步长不输默认为1
print(str3[1:4])
print(str3[:4])
# 终止值不输默认取到最后
print(str3[4:])
print(str3[:])
# 区间左闭右开
print(str3[4:7:1])

'''
e
ell
hell
o world
hello world
o w
'''

# 步长为负
print(str3[-1:-5])
print(str3[-1:-5:-1])
# 取值区间不在范围内不会报错，返回空字符串
print(str3[-5:-1])
print(str3[-5:-1:-1])

'''
dlro
worl

'''

5.3.3、字符串的常用函数

pycharm中，代码提示的含义：

Class：类

Method：方法

Function：函数

Field：类属性，域

Variable：变量

Property：python内置函数

Parameter：参数

Element：元素

5.3.3.1、len()函数

作用：计算字符串长度

str1 = 'hello world'
print(len(str1))
# 11

5.3.3.2、ord()函数

作用：返回字符的ASCII码

print(ord('a'))
print(chr(97))
print(ord('A'))
# 97
# a
# 65

5.3.3.3、chr()函数

作用：跟ord()相反，根据ASCII码返回相应的字符

print(chr(99))
# c

5.3.4、字符串的常用方法

5.3.4.1、find()方法

格式：find(self, sub, start=None, end=None)

作用：在字符串中找第一个出现的字符串的下标，如果找不到则返回-1，可以传入start和end在指定的范围内找

str2 = 'nihao,feichanghao'
# 查询第一个a元素的下标索引
print(str2.find('a'))
# 查询下标索引位置从10到17的区间中的第一个a的下标索引
print(str2.find('a',10,17))

5.3.4.2、index()方法

作用：在字符串中找第一个出现的子串的下标，如果找不到抛 ValueError 异常

str2 = 'sdfsduerbdffo45602142'
print(str2.index('e'))
print(str2.index('4'))
# 6
# 13

find()和index()方法的区别 ：find()如果在指定字符中没有找到则返回-1；而index则会抛出ValueError 异常

5.3.4.3、rfind()方法

格式：rfind(self,sub,start=None,end=None)

作用：在字符串中找最后一个出现的子串的下标，如果找不到则返回-1

str2 = 'sdfsduerbdffo45602142'
print(str2.rfind('f'))
# 11

5.3.4.4、rindex()方法

格式：rindex(self,sub,start=None,end=None)

作用：在字符串中找最后一个出现的子串的下标，如果找不到则抛ValueError异常

str2 = 'sdfsduerbdffo45602142'
print(str2.rindex('f'))
# 11

5.3.4.5、format()方法

作用：实现字符串的格式化输出

#场景一：format方法中的值按位置替换字符串中的{}
print("我叫{}，我来自{}，今年{}岁了。".format('jack','成都','10'))
# 我叫jack，我来自成都，今年10岁了。

#场景二：以索引的方式来表示替换参数，{0}位置用传入的第一个变量替换，{1}位置用传入的第二个变量替换，{2}位置用传入的第三发变量替换。可以允许传入的参数比需要的多，但不能比需要的少
print("我叫{0}，我来自{1}，今年{2}岁了。".format('jack','成都','10'))
print("我叫{1}，我来自{1}，今年{2}岁了。".format('jack','成都','10'))
print("我叫{0}，我来自{1}，今年{2}岁了。".format('jack','成都','10','北京'))
print("100+200={0}".format(100+200))
# 我叫jack，我来自成都，今年10岁了。
# 我叫成都，我来自成都，今年10岁了。
# 我叫jack，我来自成都，今年10岁了。
# 100+200=300

#场景三：在大括号中除了用下标之外，还可以用变量名，这种情况下传入的参数顺序就没有关系了。
print("我叫{name}，我来自{city}，今年{age}岁了。".format(name='jack',city='成都',age='10'))
print("我叫{name}，我来自{city}，今年{age}岁了。".format(city='成都',age='10',name='jack'))
print(str2)
# 我叫jack，我来自成都，今年10岁了。
# 我叫jack，我来自成都，今年10岁了。
# sdfsduerbdffo45602142

在Python中除了用format方法实现格式化输出之外，还可以使用格式符来实现格式化输出，常用的格式符有如下：

• %s 字符串
• %d 十进制整数
• %f 浮点数

name = "hhm"
age = 23

# 如果不使用格式化输出，会多出一个空格
print(name,'今年',age,'岁了')
# hhm 今年 23 岁了

# 使用格式化输出
print('%s今年%d岁了'%(name,age))
# hhm今年23岁了

# %.2f表示四舍五入保留2位小数输出
print("%.2f"%1.333333)
# 1.33

# 也可以使用round函数实现四舍五入，保留n位小数
print(round(1.34565528,4))
# 1.3457

5.3.4.6、count()方法

作用：统计子串出现的次数

str3 = 'sdfkaheighdhgjkfsui'
print(str3.count('a'))
print(str3.count('h'))
print(str3.count('j'))
# 1
# 3
# 1

5.3.4.7、join()方法

作用：传入一个可迭代对象，把可迭代对象中的每个元素通过调用它的字符串来拼接，返回拼接后的字符串。

# 在字符串中拼接“_”，把每个字符分开
str4 = "todayissohappy"
print("_".join(str4))
# t_o_d_a_y_i_s_s_o_h_a_p_p_y

# 错误的，join()方法传入的参数必须是迭代对象（包括字符串、列表、元组等）
# print("_".join(100))
# TypeError: can only join an iterable

# join方法中传入列表，但列表的元素必须是字符串
print(" ".join(["1","3","5"]))
# 1 3 5

#join方法中传入元组，但元组的元素必须是字符串
print(" ".join(("1","3","5")))
# 1 3 5

5.3.4.8、replace()方法

格式：replace(self,old,new[,count])

作用：替换旧的字符串成新字符串，count参数可选，表示替换几个

str5 = 'sdfskakjksgjjjsdaaaaaaa'

# 把str5中的a替换成A
print(str5.replace('a','A'))
# sdfskAkjksgjjjsdAAAAAAA

# 只替换一次
print(str5.replace('a','A',1))
# sdfskAkjksgjjjsdaaaaaaa

# 把str2中的第2个a替换成A
print(str5.replace('a','A',2).replace('A','a',1))
# sdfskakjksgjjjsdAaaaaaa

5.3.4.9、split()方法

格式：split(self,sep,maxsplit=-1)

作用：将一个字符串分裂成多个字符串返回列表的方法，详细即通过指定分隔符对字符串进行切片，如果参数maxspllit有指定值，则仅分隔maxsplit个字符串

str6 = "hello"
print(str6.split("l"))
# ['he', '', 'o']

print(str6.split("l",1))
# ['he', 'lo']

注意：当分割的子串出现在边界上，或者连续出现分割的子串时，在返回的列表中会出现空字符串。

5.3.4.10、strip()/rstrip()/lstrip()方法

作用：

• strip()方法是去除字符串两边的空格
• rstrip()方法是去除字符串右边的空格
• lstrip()方法是去除字符串左边的空格

str1 = " jkl sdfoi "

# 去除开头的空格
print(str1.lstrip())
# jkl sdfoi 

# 去除结尾的空格
print(str1.rstrip())
#  jkl sdfoi

# 去除两边的空格
print(str1.strip())
# jkl sdfoi

5.3.4.11、capitalize()方法

作用：将字符串的首字母大写，其余字母全部小写

str1 = "abdcefghijklmn"

print(str1.capitalize())
# Abdcefghijklmn

print("today is wednesday".capitalize())
# Today is wednesday

5.3.4.12、upper()方法

作用：把 字母全部转换为大写

str1 = "abdcefghijklmn"
print(str1.upper())
# ABDCEFGHIJKLMN

5.3.4.13、lower()方法

作用：把字母全部转换为小写

str1 = "ABDCEFGHIJKLMN"
print(str1.lower())
# abdcefghijklmn

5.3.4.14、title()方法

作用：字母的首字母都大写，标题化

str3 = "hello new world"
print(str3.title())
# Hello New World

5.3.4.15、endswith()方法

作用：判断字符串以xx结尾

str1 = "abdcefghijklmn"
print(str1.endswith('f'))
print(str1.endswith('n'))
# False
# True

5.3.4.16、startswith()方法

作用：判断字符串以xx开头

str1 = "abdcefghijklmn"
print(str1.startswith('a'))
print(str1.startswith('b'))
# True
# False

5.3.4.17、以is开头的方法

所有is开头的方法返回结果都是布尔值（True或者False）

• isalnum()： 字符串中所有字符都是字母或数字且非空则返回True
• isalpha()： 字符串中所有字符都是字母且非空则返回True
• isdigit()： 字符串中所有字符都是数字且非空则返回True
• isupper(): 字母都为大写且非空返回True
• islower(): 字母都为小写且非空返回True
• istitle(): 单词的首字母都为大写且非空返回True

print("we123".isalnum())
print("".isalnum())
print("%^*".isalnum())
print("we123".isalpha())
# True
# False
# False
# False

举例：从键盘输入密码，判断密码是否是由数字组成，如果是返回输入正确，否则返回输入错误

str1 = input("请输入密码：")
if str1.isdigit():
    print("输入正确")
else:
    print("输入错误")
       
# 请输入密码：123156
# 输入正确

# 请输入密码：sdfsd
# 输入错误

5.3.5、字符串的驻留机制

在编程语言中，=表示赋值，==表示等于，is表示判断两个对象是否是同一个对象(内存地址)，==与is的区别是：==比较的是值，is比较的是内存地址。

字符串的驻留机制：在存放两个相同的字符串时，是否申请新的内存空间来分别存放取决于字符串的复杂程度（有多种类型的字符，如果只有一种即便很长那也不算复杂）

str1="helloworldnihao"
str2="helloworldnihao"
str3="monday%^ sunday"
str4="monday%^ sunday"

print(str1==str2)
# True

print(str1 is str2)
# True

print(id(str1))
# 2433156314160

print(id(str2))
# 2433156314160

print(str3==str4)
# True

print(str3 is str4)
# False

print(id(str3))
# 2433156279920

print(id(str4))
# 2433161895664

5.3.6、转义字符

在编程语言中，定义了一些特殊字符来表示特定的含义，这被称为转义字符，之所以叫转义是因为字符原本的含义发生了改变。比如：

# \' ：表示单引号，在单引中输出单引时需要用这个转义符
# \" ：表示双引号，在双引中输出双引时需要用这个转义符
# \""" ：表示三引号，在三引中输出三引时需要用这个转义符
# \\ ：表示反斜线，在输出反斜线的时候需要用到
# \t ：表示水平制表符，作用类似于tab健，在输出需要有间隔时使用
# \n ：换行符，在输出时，需要换行时使用
#  ' ：单引号，双引号里面可以直接使用单引号
print("i'm a boy")
# i'm a boy
#  " ：双引号，单引号里面可以直接使用双引号
# \ ：反斜杠\，如果刚好遇到"\test"这种，系统会把\t识别成转义字符，这时要在前面再加一个\，如果路径很长，可以在最前面加个r
print("\\test")
print(r"c:\test\rh.txt")
# \test
# c:\test\rh.txt
#  \x ：表示后面的字符是十六进制数

Python 字符串前面加r, b, f的含义

r：字符串前加 r

• 去掉反斜杠的转移机制。

例：r"\n\n” # 表示一个普通生字符串 \n\n，而不表示换行了。
b： b" " 前缀表示：字符串是 bytes 类型。

• 网络编程中，服务器和浏览器只认bytes 类型数据。

f：字符串前加 f

• 以 f 开头表示在字符串内支持大括号内的python 表达式

5.4、列表-list

5.4.1、列表的声明

• 列表是一组有序的元素，它里面的元素可以是数字、字符串、甚至可以是列表，元素跟元素之间用逗号分隔。
• 列表的声明：通过[]或list()或列表推导式来声明（一维列表、多维列表）
• 声明一个列表：

# 声明一个空列表
list1 = []
print(type(list1),len(list1))
#  0

# 声明一个非空列表
list2 = ['a',1,5,'hello',[2,4,6,'world']]
print(type(list2),len(list2))
#  5

# 通过创建list对象来声明一个列表
list1 = list("hello")
print(list1)
# ['h', 'e', 'l', 'l', 'o']

num = 23314
# print(list(num)) # 错误的，不能转换
# TypeError: 'int' object is not iterable

#通过列表推导式来声明一个列表
print([i for i in range(1,101) if i%2==0])
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]

• 一维列表和二维列表

  • 一维列表：[1,2,3]
  • 二维列表：[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

• 修改列表中的元素

list2=['a',1,5,'hello',[2,4,6,'world']]
print(list2) # 修改前
# ['a', 1, 5, 'hello', [2, 4, 6, 'world']]

# 修改列表中的5为99
list2[2] = 99
print(list2) # 修改后
# ['a', 1, 99, 'hello', [2, 4, 6, 'world']]

5.4.2、列表的切片

• 列表的切片：规则与字符串的切片类似，但它返回的是一个列表

list1 = [1,3,4,5,6,7,8,9,0,123,4566,888,[345,567,999],"hello,中国"]

print(list1[1]) # 取下标索引为1的元素
# 3

print(list1[:6]) # 取下标索引默认从0开始到6结束步长默认为1的元素
# [1, 3, 4, 5, 6, 7]

print(list1[::]) # 全部默认，取整个列表
# [1, 3, 4, 5, 6, 7, 8, 9, 0, 123, 4566, 888, [345, 567, 999], 'hello,中国']

print(list1[::-1]) # 全部默认，取整个列表的倒序
# ['hello,中国', [345, 567, 999], 888, 4566, 123, 0, 9, 8, 7, 6, 5, 4, 3, 1]

print(list1[12][1]) # 取列表中的列表里的元素
# 567

print(list1[13][1]) # 取列表中的字符串里的元素
# e

5.4.3、列表的常用函数

• len(list)
  • 作用：计算列表的长度，即计算列表中的元素个数

list1 = [1,2,3,4,"niaoogho","你好","a","z","A"]
print(len(list1))
# 9

• max(list)
  • 作用：取列表中的最大值

# 字母排序是根据ASCII码排序
# 汉字排序是根据编码格式来排序
list1 = ["niaoogho","你好","a","z","A"]
print("最大值是：",max(list1))
# 最大值是： 你好

• min(list)
  • 作用：取列表中的最小值

# 字母排序是根据ASCII码排序
# 汉字排序是根据编码格式来排序
list1 = ["niaoogho","你好","a","z","A"]
print("最大值是：",min(list1))
# 最大值是： A

• sorted(list,reverse=False)
  • 作用：对列表的元素排序，返回排序后的新列表，默认是升序

list1=[1,5,2,-1]
# 升序排列
print(sorted(list1))
# [-1, 1, 2, 5]

# 降序排列
print(sorted(list1,reverse=True))
# [5, 2, 1, -1]

5.4.4、列表的常用方法

5.4.4.1、append()

• 作用：在列表的末尾增加一个元素

list1 = [1,2,4,5,65,"真的"]
print(list1)
# [1, 2, 4, 5, 65, '真的']

list1.append(300)
print(list1)
# [1, 2, 4, 5, 65, '真的', 300]

list1.append([400,500])
print(list1)
# [1, 2, 4, 5, 65, '真的', 300, [400, 500]]

5.4.4.2、insert()

• 格式：insert(self,index,value)
• 作用：在列表中下标为index的位置插入元素value（操作之后元素value的下标为index）添加单个元素

list1 = [1,2,4,5,65,"真的"]

# 在元素下标为3的位置插入999
list1.insert(3,999)
print(list1)
# [1, 2, 4, 999, 5, 65, '真的']

# 在超出索引位置添加？- 会添加在列表的最后
list1.insert(8,88)
print(list1)
# [1, 2, 4, 999, 5, 65, '真的', 88]

5.4.4.3、extend()

• 格式：extend(可迭代对象)

• 作用：列表的拼接，添加多个元素

list1 = ["你好"]
list2=[111,222,333]

list1.extend(list2)
print(list1)
# ['你好', 111, 222, 333]

print("两个列表相加：",list1+list2)
# 两个列表相加： ['你好', 111, 222, 333, 111, 222, 333]

print("两个列表逗号拼接：",list1,list2)
# 两个列表逗号拼接： ['你好', 111, 222, 333] [111, 222, 333]

5.4.4.4、index()

• 作用：从列表中找出某个值，第一个匹配项的索引位置

list1 = [1,2,3,5,7,"zheng","很好"]

print(list1.index(2)) # 返回2的下标索引位置
# 1
# 如果查询的不在列表内？-报错：ValueError: 8 is not in list

5.4.4.5、count()

• 作用：计算元素出现的次数

list1 = [1,2,3,1,7,"zheng","很好"]
print(list1.count(1))
# 2

5.4.4.6、remove()

• 作用：删除列表中的某个元素：括号中传入要删除的元素值，不返回删除元素，返回None

list1 =["a","b","d","c"]

print("删除前",list1)
# 删除前 ['a', 'b', 'd', 'c']

print(list1.remove('a')) # 打印删除时是否返回
# None

print("删除后",list1)
# 删除后 ['b', 'd', 'c']

5.4.4.7、pop()方法

• 作用：传输要删除元素的下标，pop方法会返回删除的元素，如果不传默认删除最后一个

list1 = ["a","b","c","d","efg"]

print(list1.pop(2))
# c

print(list1)
# ['a', 'b', 'd', 'efg']

5.4.4.8、del list[index]

• 作用：删除列表或列表中的数据

list1 = [[2,4,6,"hello"],"happy",5,3]

# 根据下标索引删除单个元素
# del list1[0]
print(list1)
# ['happy', 5, 3]

# 根据下标删除区间
# del list1[1:3]
print(list1)
# [[2, 4, 6, 'hello'], 3]

# 删除整个列表
del list1
print(list1)
# NameError: name 'list1' is not defined

5.4.4.9、clear()

• 作用：清空列表，得到一个空列表

list1 = [[2,4,6,"hello"],"happy",5,3]

list1.clear()

print(list1)
# []

5.4.4.10、copy()

• 作用：复制列表

list1 = [1,233,4,5]
print(list1)
# [1, 233, 4, 5]

list2 = list1.copy()
print(list2)
# [1, 233, 4, 5]

赋值，copy，deepcopy的区别？

• 直接赋值：其实就是对象的引用（别名）。

• copy 模块的 copy 方法，拷贝父对象，不会拷贝对象的内部的子对象。

• copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

5.4.4.11、sort()

• 作用：对列表的元素排序
• 通过reverse参数来控制排序是升序还是降序，reverse只能传布尔值True或False，默认是False（升序），所以如果不传入任何参数，表示默认升序排列，数字从小到大，字符根据ASCII码来排列；
• 数值跟列表以及字符串之间不能一起排序；
• 通过key参数来控制排序的权重，即根据第几个字符来排序，如果有元素排序的条件相同，则最终排序结果跟存储的顺序保持一致。

list1 = [1,2,3,4,5]
list2 = ["a","b","A","B","a"]
list3 = ["中国","你好","加油"]

list1.sort()
print(list1)
# [1, 2, 3, 4, 5]

list2.sort()
print(list2)
# ['A', 'B', 'a', 'a', 'b']

list3.sort()
print(list3)
# ['中国', '你好', '加油']

list1.sort(reverse=True)
print(list1)
# [5, 4, 3, 2, 1]

5.4.4.12、sorted()

• 作用：sorted是内置函数，可对所有可迭代的对象进行排序操作，返回新的list。sorted函数与sort方法的区别是sorted函数会返回排序后的新列表，而sort方法不会返回。

list1 = [7,8,4,6,33,1,3]
list2 = sorted(list1)
print(list2)
# [1, 3, 4, 6, 7, 8, 33]

5.4.4.13、reverse()

• 作用：反向列表中的元素，reverse()方法和列表[::-1]的区别是前者会改变列表中的元素顺序，而后者不会改变顺序，只会把列表的元素反着取出来。

list1 = ["1","a","9","你好","heog"]
list1.reverse()
print(list1)
# ['heog', '你好', '9', 'a', '1']

print(list1[::-1])
# ['1', 'a', '9', '你好', 'heog']

print(list1)
# ['heog', '你好', '9', 'a', '1']

• 列表与元素之间的转换
  • 通过字符串的join方法可以实现列表中的元素转字符串，通过创建list类的对象可以实现字符串的元素转列表

list1=['w', 'e', 'a' ,'r', 'e', 'g', 'o', 'o', 'd', 's', 't', 'u', 'd','e', 'n', 't', 's']
print(type("".join(list1))) #列表转字符串，打印类型
# 

print("".join(list1))
# wearegoodstudents

print(list("135"))
# ['1', '3', '5']

5.5、元组-tuple

5.5.1、元组的声明

• 元组通过()或tuple()来声明
• 元组是一组有序的数，用小括号()来表示，元组的元素跟元素之间用英文逗号隔开，元组跟列表的最大区别是：元组中的单个元素不能增删改。元组通常用于保护数据而存在

#空元组
tupl0=()
print(type(tupl0),len(tupl0))
#  0

#非空元组
tup1=(1,2,5)
print(type(tup1),len(tup1))
#  3

#用tuple实例化对象来声明元组
num=123
str1="你好吗"
list1=[1,2,4,5]
# print(tuple(num)) # 报错
print(tuple(str1))
# ('你', '好', '吗')

print(tuple(list1))
# (1, 2, 4, 5)

• 声明一个只有一个元素的元组：需要加一个逗号来表明这是一个单元素的元组，否则解释器会理解成在外面加了一个普通的括号，打印类型为单个元素的类型。

5.5.2、元组的作用

1. 可以实现对数据进行保护
2. 在操作不定长参数函数时，其参数的类型就是一个元组，所以可以直接将元组进行传入
3. 在函数或者方法中返回值可以返回多个值，默认是把多个值以元组的形式返回

5.5.3、元组和列表的区别（面试问题）

列表中的元素是可变的，可以对元素进行增删改操作；元组中的元素是不可改变的，不能对元素进行增删改操作。

5.5.4、元组的切片

• 元组的切片（有序的，可以使用下标索引），切片出来的数据还是保存在元组里的规则跟字符串、列表一致

tup1=(1,2,(1,2,3),5,999,'fgjgjfs',[1,2,3])
# 不在范围内
print(tup1[1111:])
# ()

# 取下标为2的元素
print(tup1[2])
# (1, 2, 3)

# 取下标为1开始，终止值默认到最后，步长默认为1
print(tup1[1:])
# (2, (1, 2, 3), 5, 999, 'fgjgjfs', [1, 2, 3])

# 倒序？
# 取元组中的元组里的数据

5.5.5、元组的常用操作

• 元组的修改（不是修改，实际是形成了一个新的元组）

  • 转成列表间接使用列表的方法来操作，最后再转成元组

  • tup1=(1,2,(1,2,3),5,999,'fgjgjfs',[1,2,3])
    
    #  转成列表间接使用列表的方法来操作，最后再转成元组
    print(tuple([1,2,3]))
    # (1, 2, 3)
    
    print(tuple("youseeyou"))
    # ('y', 'o', 'u', 's', 'e', 'e', 'y', 'o', 'u')
    
    list1 = list(tup1)
    list1.insert(list1.index(5)+1,100)
    tup1 = tuple(list1)
    print(tup1)
    # (1, 2, (1, 2, 3), 5, 100, 999, 'fgjgjfs', [1, 2, 3])
    

  • 也可以通过切片再拼接的方式实现。注意对字符串、列表、元组都可以用+来实现拼接操作。

  • print(tup1[:4]+(100,)+tup1[4:])
    # (1, 2, (1, 2, 3), 5, 100, 100, 999, 'fgjgjfs', [1, 2, 3])
    

• 元组的删除

  • 元组只能用del来删除整个元组

  • # 元组的删除
    tup1 = (1,2,(1,2,3),5,999,'fgjgjfs',[1,2,3])
    del tup1
    print(tup1)
    # NameError: name 'tup1' is not defined
    

5.5.6、元组的常用函数

• len()
• max()
• min()

其中max()和min()两个函数要保证比较的元素类型一致

5.6、字典dict

5.6.1、字典的声明

• 声明方式：通过{}或dict()或字典推导式来声明
• 字典的特点：
  • 字典是无序的，由键key和对应的值value组成；
  • 字典的键必须是唯一的，值可以不唯一；
  • 每个键与值之间用英文的冒号:隔开，两个键值对之间用英文逗号,隔开

# 字典的声明
# 创建空字典
dict1 = {}
print(type(dict1),len(dict1))
#  0

# 创建非空字典
dict2={"名称":"乔峰","年龄":18}
print(dict2,type(dict2),len(dict2))
# {'名称': '乔峰', '年龄': 18}  2

# 键重复的例子
# dict3={"名称":"乔峰","年龄":18,"年龄":22}

#通过dict来实例化对象（转字典）
dict4 = dict(name="xiaoming",age=8,like1="篮球")
print(dict4)
# {'name': 'xiaoming', 'age': 8, 'like1': '篮球'}

#通过字典推导式声明{结果 for 变量 in 迭代对象} 或者 {结果 for 变量 in 迭代对象 if 布尔表达式}；
people = [('小红', 18), ('小明', 45), ('小王', 22)]
dict3 = {k:v for k,v in people}
print(dict3)
# {'小红': 18, '小明': 45, '小王': 22}

5.6.2、根据key取value

方法1：需要根据键名去取，格式：字典名[键名]，注意这里一定是传入键名根据键名去取键值。

方法2：通过get方法取键值。

区别：方法1，如果key不存在，报KeyError；方法2则返回None。

# 通过key值取
dict2 = {"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
print(dict2["名称"])
# 乔峰

print(dict2["喜欢"][0])
# 阿朱

# 通过get方法去取键值
print(dict2.get("年龄"))
# 18

5.6.3、获取字典的所有键，值，以及键值对

• keys()：获取字典的所有键，返回一个可迭代序列
• values()：获取字典的所有值，返回一个可迭代序列
• items()：获取字典的所有键值对，返回一个可迭代序列

注意：以上函数返回的是一个可迭代序列，而不是列表，但可以转成列表

5.6.4、修改字典

• 修改已存在的值

# 修改已存在的值
dict2 = {"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
#找到已在的key，然后重新赋值，修改的是value
dict2["名称"] = "段誉"
print(dict2)
# {'名称': '段誉', '年龄': 18, '喜欢': ['阿朱', '阿紫']}

• 新增键值对-单个

在字典中增加一个元素（键值对），格式：字典名[键名]=键值，如果键名在字典中不存在就会增加，如果已存在就会修改它的键值

dict2={"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
dict2["虚竹"] = "憨子"
print(dict2)
# {'名称': '乔峰', '年龄': 18, '喜欢': ['阿朱', '阿紫'], '虚竹': '憨子'}

• 新增多个键值对：update()方法
• 作用：在字典中增加多个键值对，相当于字典的拼接，如果键名重复就覆盖原来的键值

dict1={"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
dict2={"学历":"高中","毕业时间":2010,"city":"绵阳"}
dict1.update(dict2)
print(dict1)
# {'名称': '乔峰', '年龄': 18, '喜欢': ['阿朱', '阿紫'], '学历': '高中', '毕业时间': 2010, 'city': '绵阳'}

dict1.update({"性别":"Female","公司":"华为"})
print(dict1)
# {'名称': '乔峰', '年龄': 18, '喜欢': ['阿朱', '阿紫'], '学历': '高中', '毕业时间': 2010, 'city': '绵阳', '性别': 'Female', '公司': '华为'}

# 字典相加不能用+
print(dict1+dict2)
# TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

5.6.5、字典的删除

5.6.5.1、del关键字

作用：删除整个字典或者根据键删除指定的键值对

dict1={"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
#删除某个键值对-用del 字典名[键名]的方式来删除指定的键值对
del dict1["名称"]
print(dict1)
# {'年龄': 18, '喜欢': ['阿朱', '阿紫']}

del dict1
print(dict1)
# NameError: name 'dict1' is not defined

5.6.5.2、pop()

作用：pop方法根据键名删除键值对，并返回键值，如果找不到键名就返回传入的default参数或者KeyError

dict1={"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
print(dict1.pop("年龄"))
# 18

print("删除后：",dict1)
# 删除后： {'名称': '乔峰', '喜欢': ['阿朱', '阿紫']}

5.6.5.3、popitem()

作用：删除并返回字典的最后一个键值对，以元组返回。

dict1={"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
print(dict1.popitem())
# ('喜欢', ['阿朱', '阿紫'])

print("删除后：",dict1)
# 删除后： {'名称': '乔峰', '年龄': 18}

5.6.5.4、clear()

作用：清空字典

dict1={"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
dict1.clear()
print(dict1)
# {}

5.6.5.5、copy()

作用：复制字典

dict1={"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]}
dict2=dict1.copy()
print(dict1)
# {'名称': '乔峰', '年龄': 18, '喜欢': ['阿朱', '阿紫']}

print(dict2)
# {'名称': '乔峰', '年龄': 18, '喜欢': ['阿朱', '阿紫']}

获取k值和value值、获取keys、values
for k,v in dict2.items()
获取key值和value值后交换

5.6.6、字典的嵌套

字典中的key可以是数值型，字符串，元组（不可变数据类型），不能是list和dict；value可以是数值型，字符串，元组，列表或者另一个字典（可以是任何数据类型）。

dict1={"信息":{"名称":"乔峰","年龄":18,"喜欢":["阿朱","阿紫"]},"级别":[1,2,4],"排名":(1,2,3)}
#1.求年龄
print(dict1["信息"]["年龄"])
# 18

#2.求"阿朱"
print(dict1["信息"]["喜欢"][0])
# 阿朱

#3.修改年龄为20
dict1["信息"]["年龄"] =20
print(dict1)
# {'信息': {'名称': '乔峰', '年龄': 20, '喜欢': ['阿朱', '阿紫']}, '级别': [1, 2, 4], '排名': (1, 2, 3)}

5.6.7、在格式化输出中传入字典

#字符串
print("小明喜欢%s，今年%d岁了"%("小花",9))
# 小明喜欢小花，今年9岁了

#1.字典（类型要对应）
print("小明喜欢%(name)s，今年%(age)d岁了"%{"name":"小花","age":9})
# 小明喜欢小花，今年9岁了

##format -这里传参时，*表示是元组，**表示字典，这里传的是字典，是一个整体，需要用**来解包，把字典解包为单个键值对，才能取到
print("小明喜欢{name}，今年{age}岁了".format(**{"name":"小花","age":9}))
# 小明喜欢小花，今年9岁了

dict1={"name":"小花","age":9}
print("小明喜欢{name}，今年{age}岁了".format(**dict1))
# 小明喜欢小花，今年9岁了

5.7、集合set

5.7.1、集合的声明

• 集合的声明：集合通过{}或set()或集合推导式来声明。
• 集合的特点：集合是一个无序的不重复元素序列，集合中的元素可以是任意不可变的数据类型

#定义空集合
set1 = set()
set2 = {}# 会表示字典类型
print(type(set1),len(set1))
#  0

#定义非空集合
set1={9,1,5,6,5,1,2,2}
set2 = {"k","k","k","khjj"}
print(type(set1),len(set1))
#  5

• 利用集合中的元素不可重复的特点对列表、元组、字符串去重

list1=[1,1,1,2,3,2]
print(type(set(list1))) #得到的是一个集合
# 

#列表转换成集合
print(set(list1))
# {1, 2, 3}

#集合转换成列表
print(list(set(list1)))
# [1, 2, 3]

tup1=(1,1,1,3,3,3)
#元组转换成集合
print(set(tup1))
# {1, 3}

#集合转换成元组
print(tuple(set(tup1)))
# (1, 3)

str1 = "aaaaffffcccc"
print("".join(set(str1)))
# caf

print((set(str1)))
# {'c', 'a', 'f'}

5.7.2、集合的运算

集合的运算：交集、并集、差集、对称差集

• 交集：取两个集合的公共部分，也就是同时存在两个集合中的元素

set1={9,1,5,6,5,1,2,2}
set2={1,6,2,20,50}

# 运算符
print(set1&set2)
# {1, 2, 6}

# 方法
print(set1.intersection(set2))
# {1, 2, 6}

• 并集：两个集合中的所有元素，重复的元素只算一次

#运算符
print(set1|set2)
# {1, 2, 5, 6, 9, 50, 20}

#方法
print(set1.union(set2))
# {1, 2, 5, 6, 9, 50, 20}

• 差集： set1-set2 的结果存在于 set1 中但不存在于 set2 中的元素（ set1减去set1和set2的交集 ）

#运算符
print(set1-set2)
# {9, 5}

#方法
print(set1.difference(set2))
# {9, 5}

• 对称差集：取两个集合的交集，然后根据交集取两个集合的补集，最后将补集取并集（并集减去交集），即去除两个集合的交集，各自剩下的元素组成一个新的集合

#运算符
print(set1^set2)
# {50, 20, 5, 9}

#方法
print(set1.symmetric_difference(set2))
# {50, 20, 5, 9}

举例：利用集合来判断两个字典的差异。

expect={"name":"张三","age":20,"sex":"男"}
actual={"name":"李四","heigh":170,"sex":"男"}
#实现断言：如果预期和实际不一致，要打印出它们的差异，输出：预期是{"name":"张三","age":20}实际是{"name":"李四","heigh":170}
set_expect=set(expect.items())
set_actual=set(actual.items())
print(set_expect)
print(set_actual)
print("预期是{}实际是{}".format(dict(set_expect-set_actual),dict(set_actual-set_expect)))

5.7.3、集合的常用方法

• add(x):

  • 作用：将元素x添加到集合中，如果元素已存在，则不进行任何操作

  • set1 = {1,2,3,4,5}
    set1.add("nihao") #不能添加列表和字典
    print(set1)
    

• update(x):

  • 作用：可以添加元素，且参数可以是列表，元组，字典等，除了数值型

  • set1 = {1,2,3,4,5}
    set1.update([1,6,7])#要添加可迭代的对象，添加字典时，只添加key值
    print(set1)
    

• remove(x)方法:

  • 作用：将元素x从集合中移除，如果元素不存在，则会发生错误

  • #remove
    set1 = {1,2,3,4,5}
    set1.remove(3) #不会返回删除的值
    print(set1)
    

• discard(x)方法:

  • 作用：移除集合中的元素，且如果元素不存在，不会发生报错

  • #discard
    set1.discard(3) #也不会返回删除的值
    print(set1)
    

• pop():

  • 作用：随机删除集合中的一个元素

  • #pop
    set1.pop()#不用传参数，且随机删除一个元素(每次删除的都是集合排序里的第一个元素)，并
    返回删除的元素
    print("删除前",set1)
    print(set1.pop())
    print("删除后",set1)
    

• del关键字 ：

  • 作用：删除整个集合

  • #del,删除整个集合
    del set1
    print(set1) # 删除后打印会报错
    

• len()函数:

  • 作用：计算集合s元素的个数

  • set1 = {1,2,(2,3),"hello"}
    print(len(set1))
    

• copy():

  • 作用：复制集合

  • set1 = {1,2,(2,3),"hello"}
    set2 = set1.copy()
    print(set1,set2)
    

• clear()：

  • 作用：清空集合

  • set1 ={1,2,4}
    set1.clear()
    print(set1) # 清空过后为空集合set()
    

5.8、range序列

• range是不可变的序列，元素为int类型，通常和for循环结合起来使用
• range(起始值=0，终止值，步长=1)：表示以指定的步长从起始值取到终止值-1，取值为左闭右开
  • 如果只传一个值，则表示终止值：range(3)
  • 如果传两个值，则表示，起始和终止值：range(1，3)
  • 如果传三个值，则表示起始，终止值和步长：range(1,10,2)

for i in range(5):
print(i)
for i in range(1,5):
print(i)
for i in range(1,5,2):
print(i)

5.9、布尔型bool

• 布尔型 bool ：布尔型只有两个结果即True和False，在python中，布尔型跟数值型参与运算时，
  True相当于1，False相当于0
• 可以用实例化 bool 类的对象把一个对象转成布尔值，在python中，空字符串、空列表、空元组、
  空字典、空集合都被当做是False；非空即True

a=True
print(type(a))
print(a+5)
print(False*100)
print(bool(111)) #True
print(bool("fff")) #True
print(bool([1,2,4])) #True
print(bool(3,)) #True
print(bool({"A":1})) #True
print(bool({3,'a'})) #True
print(bool("")) #False
print(bool([])) #False
print(bool(())) #False
print(bool({})) #False
print(bool(set())) #False
print(type({}))
print(type(set()))

5.10、特殊类型None

• None：是python中的一个特殊的数据类型，在函数没有返回值的时候，输出函数的执行结果得到
  的就是None。

print(type(None))
list1=["nihao",2,3]
print(list1.remove(2)) #删除函数，这个只是删除数据没有返回数据，所以打印的是None

• None与0，null，空字符串，空列表不同
  • None与其他任何数据类型比较都返回False
  • null为 java 里的空，和None一样，都是没有元素

5.11、数据类型总结

5.11.1、可变和不可变类型（对象）

所谓可变对象，是指对象的内容是可变的，比如修改对象的内存时对象的内存地址不改变，例如 list。而不可变的对象则相反，当改变它的内容时对象的内存地址也会改变。

• 可变数据类型：List（列表）、Dictionary（字典）、Set（集合）
• 不可变数据类型：Number（数字）、String（字符串）、Tuple（元组）

num1=100
print(id(num1))
num1=101
print(id(num1))
list1=[1,2]
print(id(list1))
list1.append(3)
print(list1)
print(id(list1))

5.11.2、可迭代和不可迭代的类型（对象）

• 可迭代即可以重复的取出数据，存在 iter() 方法的，就是可迭代的对象
  • 可迭代：List（列表）、Dictionary（字典）、Set（集合）、String（字符串）、Tuple（元
    组）
  • 不可迭代：Number（数字）、 bool （布尔类型）

#数据类型，后面能有__iter__()方法，就是可迭代的
[].__iter__()
"".__iter__()
{2,1}.__iter__()
{"name":"小明","age":18}.__iter__()

5.11.3、有序的和无序的类型（对象）

• 所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号(称为索引)访问它们。
  • 有序：List（列表）、String（字符串）、Tuple（元组）
  • 无序：Dictionary（字典）、Set（集合）
    • 字典在3.6之前的版本是无序的，从3.6版本开始，字典是有序的，字典的顺序就是元素存入的顺序

5.11.4、值类型和引用类型

Python数据类型分为值类型和引用类型， 下面我们看下它们的区别：

• 值类型：int、float、str、tuple，本身不允许被修改
• 引用类型：list、set、dict，本身允许被修改

六、Python运算符

• 算数运算符
• 比较运算符
• 逻辑运算符
• 三目运算符
• 身份运算符
• 成员运算符
• 赋值运算符

6.1、算数运算符

以下假设变量 a=2，变量 b=3：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果5
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -1
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 6
/	除 - x除以y	b / a 输出结果 1.5
%	取模 - 返回除法的余数（取余）	b % a 输出结果 1
**	幂 - 返回x的y次幂	a**b 为2的3次方为8
//	取整除 - 向下取接近商的整数	9//2结果为4，-9//2结果为-5

6.2、比较运算符

以下假设变量 a=2，变量 b=3：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b)返回False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。 这分别与特殊的变量True和False等价。 注意，这些变量名的大写。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b)返回False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b)返回True。

注意：<> 在 python2.x 中这个也表示不等于，在 python3.x 中不支持这个符合

6.3、逻辑运算符

• and：逻辑与，表示两个条件同时满足
• or：逻辑或，表示两个条件满足其中一个
• not：逻辑非，表示取反

优先级：括号 > not > and > or

6.4、身份运算符

• is：判断两个对象是同一个对象
• is not：判断两个对象不是同一个对象

is比较的是两个变量的内存地址，is not和is相反。运算结果是布尔值。

a="hello world"
b="hello world"
print(id(a),id(b))
print(a is b)

is与==的区别： is比较的是内存地址，是判断两个对象是否是同一个对象，==比较的是值，是判断两个对象的值是否相等。

6.5、成员运算符

• in
• not in

格式：a in b，表示判断a是否是b的成员

if 'a' in 'hashdaskak':
    print("在的")
if "b" not in 'hashdaskak':
    print("不在")
#in经常用在for循环中，遍历元素
for i in [1,2,3,4,5,6,7,8]:
    print(i)
#判断某个值是否在字典的value中
dict1={"name":"张三","age":20}
if "张三" in dict1.values():
    print("在里面")

6.6、赋值运算符

以下假设变量a为2，变量b为3：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值。 Python3.8 版本新增的运算符。

num_1 = 5
print(num_2 := num_1 + 5)
print(num_2)

#输出：
10
10

#在这个示例中，赋值表达式可以避免调用len()两次
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

6.7、三元运算符

语法： 变量名= 结果值1 if bool表达式 else 结果值2

#用if...else...语句实现
year1 = int(input("请输入年份："))
if year1%2 ==0:
    print("偶数")
else:
    print("奇数")

#三元运算符格式
year1 = int(input("请输入年份："))
print("偶数" if year%2==0 else "奇数")

七、流程控制

• 条件判断
• 循环

7.1、条件判断

条件判断用if语句实现，if语句的几种格式：

• if… 表示满足条件，则执行相应的操作，否则什么都不执行；
• if…else… 表示如果满足条件则执行if后面的操作，否则执行else后面的操作；
• if…elif…elif…else… 表示多条件判断，如果满足第一个条件就执行第一个操作，如果满足第二个条件就执行第二个操作，…，如果都不满足就执行else后面的操作。

7.1.1、if

作用：如果if后面的布尔表达式值为True就执行if下的代码块，如果为False就不执行

#从键盘输入一个数字，如果大于10就输出“大于10”
num1=int(input("请输入一个数字："))
if num1>10:
    print("大于10")

#结合布尔值（为True则执行，为False则不打印
if 8:
    print("你好")
if "不为空":
    print("真的")

#结合成员运算符（in、not）-满足条件执行print，不满足则不执行
str1 = "adgcgag"
if "ad" in str1:
    print("在里面")

7.1.2、if…else…

作用：如果if后面的布尔表达式值为True就执行if下的代码块，如果为False就执行else下的代码块。

#从键盘输入一个数字，如果大于10就输出“大于10”，如果不大于10就输出“不大于10”
num1=int(input("请输入一个数字："))
if num1>10:
    print("大于10")
else:
    print("不大于10")
#从键盘输入一个整数，如果整数是奇数，就打印奇数，如果不是奇数，就打印偶数
third=int(input("请输入一个整数："))
if third%2==1:
    print("奇数")
else:
    print("偶数")
#注意if和else是同级的，应该对齐。

7.1.3、if…elif…elif…else…

作用：从第一个条件开始逐一判断，遇到第一个满足的条件就执行它下面的语句，并结束判断不再往下判断。

#从键盘输入一个数字，如果大于10就输出“大于10”，如果小于10就输出“小于10”，否则输出等于10
num1=int(input("请输入一个数字："))
if num1>10:
    print("大于10")
elif num1<10:
    print("小于10")
else:
    print("等于10")
#举例：当遇到某个条件满足时就不会再往下判断
forth=int(input("请输入一个整数："))
if forth<10:
    print("小于10")
elif forth>=10:
    print("大于10")
elif forth>=20:
    print("大于20")
else:
    print("其它")

7.2、循环

• while循环
• for循环

7.2.1、while循环

while循环：当满足循环条件时就执行循环体里的代码，直到循环条件不满足为止。中括号表示else是可选的，如果有else，那么else后面的代码会在循环正常结束后执行。使用while循环一定要有修改循环条件的语句，否则会造成死循环（在某条件下，一直执行语句，直到条件为False）。

# 不带else语句
i=1 #给个初始值
while i<=10: #1.条件限制
    print(i)
    i+=1 #2.条件，递增
#两个条件要结合，如果不限制，会导致死循环

#带else语句
i=1
while i<=10: #1.条件限制
    print(i)
    i+=1 #2.条件，递增
else:
    print("打印完毕")

#实现1+2+3+...+100，并输出计算结果
num1=0
i=1
while i<=100:
    num1+=i
    i+=1
else:
    print(num1)
#思考：1*2*3*...*100 ？

1. 当布尔表达的值为True的时候，就执行循环体的代码，直到布尔表达的值为False的时候或者被break;
2. else 语句是可选的，如果有else语句，当循环正常结束（不是被break语句结束的情况）后会执行else后面的语句，如果循环是被break掉，就不会执行else后面的操作。

7.2.2、for循环

迭代(Iteration)：指重复执行某个操作，迭代最常用的表现就是遍历，经常用for循环来遍历可迭代对象（ Iterable ），常见的可迭代对象包括字符串、列表、元组、集合和字典等。

#1.将字符串"helloworld"遍历出来添加到列表list1中
list1=[]
for i in "helloworld":
    list1.append(i)
print(list1)

#2.遍历元组中的元素
tuple1 = (1,3,5,6,7)
for i in tuple1:
    print(i)
else:
    print("遍历完成")

#3.用for循环遍历字典
dict1={"姓名":"张三","性别":"男","年龄":20}
#遍历字典，默认取到的是字典的key
for i in dict1:
    print(i)
#遍历字典的key
for i in dict1.keys():
    print(i)
#遍历字典的value
for i in dict1.values():
    print(i)
#遍历字典的键值对
for i,j in dict1.items():
    if i=="年龄":
        print(i,j)

#4. 用for循环实现1+2+3+...+100，并输出计算结果

while循环和for循环的区别：while循环执行前，循环次数是不确定的；for循环在循环前执行次数是已经确定的。

7.2.3、循环的嵌套

7.2.3.1、while中套while循环

# 在10中找两个数i和j，满足条件j <= (i / j)时，如果i能除尽j则打印“能除尽”并打印i和j的值，如果
不满足则打印“不满足条件”并打印不满足条件的i和j的值
i = 2
while (i < 10):
    j = 2
    while (j <= (i / j)):
        if not (i % j):
            print("能除尽",i,j)
        j = j + 1
    else:
        print("不满足条件",i,j)
    i = i + 1
print("算完")

7.2.3.2、for循环中套for循环

# 九九乘法表
for i in range(1,10): # 依次取数1到9
    for j in range(1,i+1): # 根据i的取值来取值，i取1时,j的范围也是1
        print("{} x {} = {}\t".format(j,i,i*j),end="") # 根据上面两个循环取出的书打印格式化数据。
    print()# 把一次循环的数据打印完成后换行

7.2.3.3、冒泡排序

arr = [64, 34, 25, 12, 22, 11, 90]
# 遍历所有数组元素
for i in range(len(arr)):
    for j in range(0, len(arr) - i - 1):
        if arr[j] > arr[j + 1]:
            arr[j], arr[j + 1] = arr[j + 1], arr[j]
else:
    print(arr)

7.2.4、循环中的continue/break/pass语句

• continue
• break
• pass

7.2.4.1、continue语句

作用：continue的作用是结束本次循环（在某一次循环中遇到continue语句时，直接结束本次循环，不执行continue后面的代码，而开始执行下一次循环）。

# 在0到10的数字中打印所有奇数，不是奇数的就不打印出来
a = 0
while a < 10:
    a += 1
    if a%2 ==0:
        continue # 跳过本次循环，进入下一次循环
    print("奇数",a)
else:
    print("没有奇数了")

#3、输出0到100之间被3整除的整数，如果这个数能被5整除则不输出
for i in range(101):
    if i%3==0:
        if i%5==0:
            continue
        print(i)

7.2.4.2、break语句

作用：是结束本层循环，可以跳出for和while的循环体(所有循环)，任何对应的循环else块将不执行。

# 整数0到10中，取能被2整除的数，取到第一个数就结束循环，不执行后面的代码
a = 0
while a < 10:
    a += 1
    if a%2 ==0:
        break # 满足上面条件了，直接结束本层所有循环，不执行后面的语句
    print("奇数",a)
else:
    print("没有奇数了")

7.2.4.3、pass语句

作用：是空语句，是为了保持程序结构的完整性。不做任何事情，一般用做占位语句

# 输出 Python 的每个字母
for str1 in 'Python':
    if str1 == 'h':
        pass # 占位，不做任何操作
    print(str1)

# 每层不同的*数量，依次递增(差一）
for a in range(6):
    print("*"*a)

# 每层不同，递增差二
#1.方法1
for b in range(1,8,2):
    print("*"*b)

#2.方法二
b = 5
for b in range(1,b+1):
    print("*"*(2*b-1))

# 金字塔
cengshu = 7
for b in range(1,cengshu+1):
    print(" "*(cengshu-b),"*"*(2*b-1))

# 金字塔，中间为空
for i in range(6): #循环6次打印6行
    for j in range(5-i): #打印空格每次循环递减
        print(' ',end='')
    for q in range(2*i+1): #打印星星
        if q==0 or q==2*i: #判断打印星星位置，在开头，结尾和最后一行打印星星
            print('*',end='')
        else:
            print(' ',end='')
    print() #每行循环结束后换行

八、推导式

• 列表推导式
• 字典推导式
• 集合推导式
• 生成器推导式

8.1、列表推导式

列表推导式的语法：[结果 for 变量 in 可迭代对象] 或者 [结果 for 变量 in 可迭代对象 if 布尔表达式]

# 列表推导式
# 普通形式
list1 = []
for i in range(1,101):
    if i%2==0:
        list1.append(i)
print(list1)
# 列表推导式完成
print([i for i in range(1,101) if i%2==0])
# 列表推导式不加if
print([i for i in range(2,101,2)])
#统计字符串中只出现一次的字符，以列表返回字符串
str1 = "helloworld"
print([i for i in str1 if str1.count(i)==1])

8.2、字典推导式

语法：{结果 for 变量 in 迭代对象} 或者 {结果 for 变量 in 迭代对象 if 布尔表达式}；注意字典推导式的结果是键值对，即 key:value

# 字典推导式
tupl1 = (("姓名", "张三"), ("年龄", 20), ("体重", 190), ("身高", 180))
print({i: j for i, j in tupl1})
# 交换key和value的位置
print({j:i for i,j in tupl1})
# 加判断条件
print({i:j for i,j in tupl1 if j != 190})
# 统计字符串中每个字符出现的次数，以字典返回
str1 = "helloworld"
print({i:str1.count(i) for i in str1})
# 统计字符串中只出现一个的字符，以字典返回字符及出现次数
str1 = "helloworld"
print({i:str1.count(i) for i in str1 if str1.count(i)==1})
print({i for i in str1 if str1.count(i)==1})

8.3、集合推导式

语法：{结果 for 变量 in 迭代对象} 或者 {结果 for 变量 in 迭代对象 if 布尔表达式}；集合推导式跟字典推导式的区别是：字典推导式的结果是键对，集合推导式的结果是单个结果

# 集合推导式
dict1 = {"姓名":"张三","年龄":20,"体重":180,"身高":180}
print({x for x in dict1.keys()})
print({x for x in dict1.values()})
# 加if判断，只取int类型的数据
print({x for x in dict1.values() if type(x)==int})

8.4、生成器推导式

语法：(结果 for 变量 in 可迭代对象)或者(结果 for 变量 in 可迭代对象 if 布尔表达式)

# 生成器推导式
d = (a**2 for a in range(1,10))
# 用元组形式展示数据
print(tuple(d))

九、函数

定义：函数就是完成特定功能的一个语句组，这组语句可以作为一个单位使用，并且取一个名字，这个名字叫做函数名

函数的作用：

1. 可以通过函数名在程序不同的地方多次调用，这样就不用在不同的地方重复编写这些语句
2. 函数是实现特定功能的一段代码，通过函数可以方便地重复使用代码，让程序的结构更清晰，方便代码的走读。
3. 函数能提高应用的模块性，和代码的重复利用率

9.1、内置函数（内建函数）