Python

Kendra919

已于 2024-04-25 21:32:14 修改

阅读量909

点赞数 21

文章标签： python 开发语言

于 2024-03-18 17:21:44 首次发布

本文链接：https://blog.csdn.net/weixin_74212619/article/details/136770032

版权

Python

一、准备工作
二、python的基础部分

一、准备工作

1.1 软件安装

1.1.1 python安装

官方网站：http://www.python.org
Windows环境下的安装
示例以python3.9.1为例

打开安装包，切记要勾选add python 3.9 to PATH

自动安装（Install Now）或自定义安装（Customize installation），自定义安装可改变安装路径，选择C盘以外的盘存储
在这里插入图片描述

默认全部勾选，点击next
选择自己要安装的目录，勾选install for all users,然后点击install进行安装
安装完成后，一定要点击disable path length limit,禁用系统的path长度自动限制，可以避免很多麻烦，完成后点击close即可

检查安装是否成功
运行----CMD进入黑窗口，输入python，能够使用exit()成功退出即可

在这里插入图片描述
遇到的问题

已经安装过就不用安装，如果出现以下界面表示已经安装过
缺少环境变量
方法一：卸载重装（选择环境变量）

方法二：此电脑—高级环境设置-----环境变量配置环境变量
丢失 … .dll文件 ----- 百度自行下载补丁文件

1.1.2 Visual Studio Code安装

官方网站：https://code.visualstudio.com/
Windows环境下的安装
右键以管理员身份运行，自行修改路径即可
所有选项默认
在这里插入图片描述
以上四项都勾选上，桌面快捷方式需要就添加即可

添加到 PATH：添加到系统环境变量中，勾选后，即可在命令行中使用 code . 即可打开 Vscode

VSCode 插件安装

简体中文语言包
python

VSCode 快捷键（Window 版）

注释：
单行注释：ctrl + k ctrl + c 或 ctrl + /
取消单行注释：ctrl + k ctrl + u（按下 ctrl 不放，再按 k+u）
多行注释：alt + shift + A
多行注释 : /**/
移动行：alt + up/down
显示/隐藏左侧目录栏 ctrl + b
复制当前行：shift + alt + up/down
删除当前行：shift + ctrl + k
控制台终端显示与隐藏：ctrl + ~
查找文件/安装 vscode
插件地址：ctrl + p
代码格式化：shift + alt + f
新建一个窗口：ctrl + shift + n
多行编辑：Ctrl + Alt + up/down

1.2 软件使用

1.2.1 python 解释器

当我们编写Python代码时，我们得到的是一个包含Python代码的以 .py 为扩展名的文本文件。要
运行代码，就需要Python解释器去执行 .py 文件。

1.2.2 编写第一个 python 程序

在写代码之前，请千万不要用“复制”-“粘贴”把代码从页面粘贴到你自己的电脑上。写程序也讲究一个感觉，你需要一个字母一个字母地把代码自己敲进去，在敲代码的过程中，初学者经常会敲错代码：拼写不对，大小写不对，混用中英文标点，混用空格和Tab键，所以，你需要仔细地检查、对照，才能以最快的速度掌握如何写程序。
在这里插入图片描述
在你的计算机上创建一个文件夹，之后在里面创建一个文件，注意，该文件最好以英文命名，后缀名是.py（.py是python的缩写，所有的python文件的后缀名是py，就相当于java的文件是以.java为后缀名的一样）。

在文件夹直接新建文本文档，文件后缀名改为 .py
VScode 中新建文件、新建文本文件，改后缀名 .py
终端写代码（无法保存）
右键打开终端

输入 python，进入到 python 的测试终端

从文件夹进入 cmd：
在当前文件夹的路径处输入 cmd ，回车
在这里插入图片描述

输入py + 文件名称 可运行（记不住文件名称可用 Tab键补全）

1.3 python的由来

Guido van Rossum（荷兰人），从阿姆斯特丹大学获得了数学和计算机硕士学位。所以他可以称得上是一名数学家，或者更确切点是精通数学与计算机的复合型人才。他希望有一种语言，这种语言能够像C语言那样，能够全面调用计算机的功能接口，又可以像shell那样，可以轻松的编程。
在这里插入图片描述
1991年，第一个Python编译器诞生。它是用C语言实现的，并能够调用C语言的库文件。从一出生，Python已经具有了：类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。

Python 是一种面向对象的解释型计算机程序设计语言，第一个公开发行版发行于 1991 年。是纯粹的自由软件，源代码和解释器 CPython 遵循 GPL(GNU General Public License)协议。
Python 语法简洁清晰，特色之一是强制用空白符(white space)作为语句缩进。Python 具有丰富和强大的库。它常被昵称为胶水语言

二、python的基础部分

全局函数：

print() ：标准的输出函数，可以在控制台上进行输出某个字符串
type() ：返回的是变量的数据类型
ord() ：获取字符整数表示 ASCII值
chr()：将编码转换为字符

每个数据类型占用的内存大小不一样

1字节 ------- byte boolean
2字节 ------ short、char
4字节 ------ int 、float
8字节 ------ long 、double

输出技巧：

定义字符串：单引号、双引号、三单引号、三双引号（注意英文符号）
转义字符：/ （输出时要输出符号与python中的部分变量冲突）
换行：/n
制表：/t

2.1 基本数据类型

python是一门 弱数据类型语言
Java 、C、C++都是强数据类型语言
在python这种弱数据类型语言中，一般声明变量的格式：

变量名称 = 变量
    a   =  10

什么是强数据类型语言？什么是弱数据类型语言？
强：当定义变量的时候，需要声明数据类型
弱：当定义变量的时候，不需要声明数据类型，系统可以根据变量的值自动判别数据类型

全局函数：

print() ：标准的输出函数，可以在控制台上进行输出某个字符串
type() ：返回的是变量的数据类型
ord() ：获取字符整数表示 ASCII值
chr()：将编码转换为字符

# type() ：返回的是变量的数据类型
>>> a = 10
>>> a
10
>>> type(a) 
<class 'int'>
>>> b = 3.14
>>> type(b)
<class 'float'>

# ord() ：获取字符整数表示 ASCII值
>>> ord("A")
65
>>> ord("a")
97

# chr()：将编码转换为字符
>>> chr(65)
'A'
>>> chr(25991)
'文'
>>> ord("中")
20013
>>> ord("文")
25991

2.1.1 变量

变量（具有名称的内存空间）：在程序的运行过程中，可以发生变化的量，就叫做变量

变量：保存程序执行过程中的数据
变量名：定义变量的标识符
变量类型：存放的数据类型
变量值：内存单元中装载的数据

变量其实是内存中的一小块区域，可以通过变量名来访问这块区域

变量的命名规范：

变量名称只能由有效字符组成（大小写字母、数字、下划线）（name+ 会报错语法错误）
不能以数字开头
不能是关键字或者保留字
变量命名尽量要有意义（name age gender）

在C语言中：
1） 数据类型 变量名;
变量名 = 对应数据类型的值;
int a;     //  int：关键字
a = 10;
2）数据类型 变量名 = 对应数据类型的值; (定义变量时直接赋值，推荐写法)
int a = 1024;
注："=" 表示赋值，变量不赋值，是不能直接使用的，会报错
比如下面代码，定义了变量c，但是没有赋值，打印的时候，直接报错
int c;
System.out.println(c)

常用命名方法：
小驼峰法：（userName）即除了第一个单词为小写，其他单词的第一个字母为大写
下划线法：（user_name）

2.1.2 标识符

标识符的命名规范：
标识符：对变量、常量、函数、类等对象起的名字
注意：python是一门弱数据类型语言，也是严格区分大小写的语言
命名规范：

第一个字符必须是字母表中的字母或者下划线，也是支持中文的
其他部分是由有效字符组成，是对大小写敏感的

2.1.3 python 中的常量

不会变化的量就叫做常量
常量最好全是大写

>>> NATIONALITY = "中国"
>>> MAX_NUM = 10000000000

2.1.4 python中的关键字

关键字：具有特殊含义的单词或者词组
保留字：目前的版本中还未使用的，但是未来可能会被使用，暂时保留，所以不建议使用

查看python中的关键字：import keyword

>>> import keyword #导入
>>> dir(keyword)
['__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__',
'__name__', '__package__', '__spec__', 'iskeyword', 'issoftkeyword', 'kwlist',
'softkwlist']
>>> keyword.kwlist
['False', 'None', 'True', '__peg_parser__', '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 = 1
File "<stdin>", line 1
if = 1
^
SyntaxError: invalid syntax
>>> or = 5
File "<stdin>", line 1
or = 5
^
SyntaxError: invalid syntax

2.1.5 数据类型

python是一门 弱数据类型语言，所以没有数据类型，这种说法是错误的
只是说 不用去声明数据类型，但是是有数据类型的
分类：基本数据类型和复合数据类型（引用数据类型）

每个数据类型占用的内存大小不一样

1字节 ------- byte boolean
2字节 ------ short、char
4字节 ------ int 、float
8字节 ------ long 、double

在Java中：

int age = 18;
double price = 3.14;

2.1.5.1 基本数据类型

数值型：

整数 int
浮点数（小数）float
复数（虚数）一般用不到

布尔类型（bool）：判断条件成不成立？一般只有两种情况 True和 Flase（首字母必须大写）

python 注重区分大小写

>>> true
Traceback (most recent call last):   #小写会报错：没有被定义
File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
>>> True
True

字符串 （在Java这种强数据类型语言中字符串是一个对象，但是在python中字符串是一种数据类型）str

定义字符串：单引号、双引号、三单引号、三双引号（注意英文符号）
字符串中可以包含任何语言

>>> s = 'hhhhh'
>>> type(s)
<class 'str'>
>>> ss = "hhhhhh"
>>> type(ss)
<class 'str'>
>>> sss = "我是中国人"
>>> type(sss)
<class 'str'>

全局函数：

print() ：标准的输出函数，可以在控制台上进行输出某个字符串
type() ：返回的是变量的数据类型
ord() ：获取字符整数表示 ASCII值
chr()：将编码转换为字符

# type() ：返回的是变量的数据类型
>>> a = 10
>>> a
10
>>> type(a) 
<class 'int'>
>>> b = 3.14
>>> type(b)
<class 'float'>

# ord() ：获取字符整数表示 ASCII值
>>> ord("A")
65
>>> ord("文")
25991

# chr()：将编码转换为字符
>>> chr(65)
'A'
>>> chr(25991)
'文'

定义字符串：单引号、双引号、三单引号、三双引号（注意英文符号）
如果字符串中包含 ’ 怎么办，
eg. 打印 I’m ok

>>> print('I'm ok')
File "<stdin>", line 1
print('I'm ok')  # 报错
^
SyntaxError: invalid syntax

最外面用双引号

>>> print("I'm ok") 
I'm ok

转义符表示（ / ）

>>> print('I\'m ok')
I'm ok
>>> print("\\")
\

如果字符串有多行内容

使用 \n
使用三单 / 双引号

>>> print("""line1
... line2
... line3
... line4""")
line1
line2
line3
line4

>>> print('''line1
... ... line2
... ... line3
... ... line4''')
line1
... line2
... line3
... line4

2.1.5.2 复合数据类型（引用数据类型）

字典、列表、元组、集合（在 python 中统一叫做容器）

type() ：返回的是这个数的数据类型
input() ：标准的输入语句，默认的返回值是 str 类型

eg.：写一段代码，输入一个数，判断这个数的数据类型

num = input("请输入一个数:")
print(type(num))

2.1.6 数据类型的转换

2.1.6.1 字符串类型转换为整型型： int()

int()：字符串类型转换为整数类型
float()：字符串类型转换为浮点数类型

写一段代码，输入一个数，判断这个数的数据类型

num = int(input("请输入一个数:"))
print(type(num))
temp = int(num)
print(type(temp))

此时输入如果是 10
输出就会变成 <class ‘int’>

2.1.6.2 字符串类型转换为浮点数类型： float()

num = float(input("请输入一个数:"))
print(type(num))

在这里插入图片描述

2.1.6.3 将其他类型转换为字符串类型：str()

#写一段代码，输入一个数，判断这个数的数据类型
num = float(input("请输入一个数:"))
print("num的值是："+str(num))

2.1.6.4 字符串的拼接方式

+str（其他类型）进行拼接
可以使用逗号（用，时不用考虑类型，使用，会有一个空格）
%s 占位符
使用{ }进行补充，使用字符串中 format（）进行拼接

+str（其他类型）进行拼接

# 输入字符串，输出字符串
num = input("请输入一个数:")
print("num的值是："+(num))

# 输入浮点型。输出字符串
num = float(input("请输入一个数:"))
print("num的值是："+str(num))

可以使用逗号（用，时不用考虑类型，使用，会有一个空格）

num = float(input("请输入一个数:"))
print("num的值是：",(num))

在这里插入图片描述

%s 占位符

num1 = int(input("请输入第一个数:"))
num2 = int(input("请输入第二个数:"))
sum = num1 + num2
print("%s和%s的和是%s"%(num1,num2,sum))

print(“%s和%s的和是%s”%(num1,num2,sum))
一个百分号 + 一个括号按顺序包含所有变量

2.1.7 常见运算符

2.1.7.1 算术运算符

+  加法运算
-  减法运算
*  乘法运算
/  除法运算
// 整除运算
%  取余运算
** 幂次方运算

** ：幂次方运算

示例：

>>> a = 10
>>> b = 3
>>> a + b
13
>>> a - b
7
>>> a / b
3.3333333333333335
>>> a * b
30
>>> a // b
3
>>> a % b
1
>>> a ** b
1000
>>> 2 ** 3
8

2.1.7.2 关系运算符

两个数之间的关系，返回结果是 bool 类型（要么是True，要么是Flase）

>  大于
<  小于
>= 大于等于
<= 小于等于
== 等于
！= 不等于

==：比较的是两个变量的值是否相等
is ：比较的两个变量的地址是否相同

2.1.7.3 逻辑运算符

多个表达式之间的关联关系，结果也是一个 bool 类型

and 且：多个条件同时成立的时候结果为 True
or 或：多个条件，至少有一个为真，结果就为 True
not 非：取反，一般会和in关键字进行连用，表示判断元素是不是在某个容器里面

示例：

>>> a = 3
>>> b = 4
>>> c = 3
>>> a > b and b > c
False
>>> a > b or b > c
True
>>> list = [1,2,3,4]
>>> 1 in list
True
>>> 5 in list
>lse
>>> 5 not in list
True
>>> 1 not in list
False

2.1.7.4 赋值运算符

python中没有自加自减的运算

=  等于
+= 加等 a = a + 1   ——  a += 1
-=
*=
/=
**=
//=

2.1.7.5 身份运算符

is  判断两个标识符是不是引用同一个对象（地址）
is not

示例：

>>> a = [1,2,3]
>>> b = a
>>> b == a
True
>>> b
[1, 2, 3]
>>> b is a
True
>>> id(a)
2440474027200
>>> id(b)
2440474027200
>>> c = a[:]  #引用的 a ，地址并不相同
>>> c
[1, 2, 3]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> a == c
True
>>> b == c
True
>>> a == b
True
>>> a is c
False
>>> b is c
False
>>> a is b
True
>>> id(a)
2440474027200
>>> id(b)
2440474027200
>>> id(c)
2440474404096

id()：查看内存地址

2.1.7.6 成员运算符

in
not in

2.1.7.7 位运算符

把数字看作二进制数据进行的运算
a = 60
b = 13
a = 0011 1100
b = 0000 1101

& ：按位与运算
参与运算的两个数，如果两个对应的位置 都为1 则为1，否则为0
a & b = 0000 1100

| ：按位或运算
只要对应的位置 有1则为1
a | b = 0011 1101

^  ：按位异或运算
不同为1，相同为0
a ^ b = 0011 0001

~ ：按位取反

<<  ：按位左移运算
a = 0011 1100
a << 2 = 1111 0000

>> ：按位右移运算
a = 0011 1100
a >> 2 = 0000 1111

示例：

>>> a = 60
>>> b = 13
>>> a & b
12
>>> a | b
61
>>> a ^ b
49
>>> a << 2
240
>>> a >> 2
15

2.1.7.8 三目运算符

其他语言中，格式：判断条件？为真的时候的结果:为假的结果
result = 5 > 3 ? 1:0

在python中：

为真的结果   if    判定条件    else  为假的结果

eg.

  True      if     5 > 3      else    False
  num1      if   num1 > num2  else    num2

示例：

num1 = int(input("请输入第一个数:"))
num2 = int(input("请输入第二个数:"))
max = num1 if num1 > num2 else num2
print(max)

2.1.8 图形化设计

turtle模块
通过 dir(turtle)，查看 turtle 中的关键字

>>> import turtle
>>> dir(turtle)
['Canvas', 'Pen', 'RawPen', 'RawTurtle', 'Screen', 'ScrolledCanvas', 'Shape',
'TK', 'TNavigator', 'TPen', 'Tbuffer', 'Terminator', 'Turtle',
'TurtleGraphicsError', 'TurtleScreen', 'TurtleScreenBase', 'Vec2D', '_CFG',
'_LANGUAGE', '_Root', '_Screen', '_TurtleImage', '__all__', '__builtins__',
'__cached__', '__doc__', '__file__', '__forwardmethods', '__func_body',
'__loader__', '__methodDict', '__methods', '__name__', '__package__',
'__spec__', '__stringBody', '_alias_list', '_make_global_funcs',
'_screen_docrevise', '_tg_classes', '_tg_screen_functions',
'_tg_turtle_functions', '_tg_utilities', '_turtle_docrevise', '_ver',
'addshape', 'back', 'backward', 'begin_fill', 'begin_poly', 'bgcolor', 'bgpic',
'bk', 'bye', 'circle', 'clear', 'clearscreen', 'clearstamp', 'clearstamps',
'clone', 'color', 'colormode', 'config_dict', 'deepcopy', 'degrees', 'delay',
'distance', 'done', 'dot', 'down', 'end_fill', 'end_poly', 'exitonclick', 'fd',
'fillcolor', 'filling', 'forward', 'get_poly', 'get_shapepoly', 'getcanvas',
'getmethparlist', 'getpen', 'getscreen', 'getshapes', 'getturtle', 'goto',
'heading', 'hideturtle', 'home', 'ht', 'inspect', 'isdown', 'isfile',
'isvisible', 'join', 'left', 'listen', 'lt', 'mainloop', 'math', 'mode',
'numinput', 'onclick', 'ondrag', 'onkey', 'onkeypress', 'onkeyrelease',
'onrelease', 'onscreenclick', 'ontimer', 'pd', 'pen', 'pencolor', 'pendown',
'pensize', 'penup', 'pos', 'position', 'pu', 'radians', 'read_docstrings',
'readconfig', 'register_shape', 'reset', 'resetscreen', 'resizemode', 'right',
'rt', 'screensize', 'seth', 'setheading', 'setpos', 'setposition',
'settiltangle', 'setundobuffer', 'setup', 'setworldcoordinates', 'setx', 'sety',
'shape', 'shapesize', 'shapetransform', 'shearfactor', 'showturtle',
'simpledialog', 'speed', 'split', 'st', 'stamp', 'sys', 'textinput', 'tilt',
'tiltangle', 'time', 'title', 'towards', 'tracer', 'turtles', 'turtlesize',
'types', 'undo', 'undobufferentries', 'up', 'update', 'width', 'window_height',
'window_width', 'write', 'write_docstringdict', 'xcor', 'ycor']

Turtle是Python内嵌的绘制线、圆以及其他形状（包括）文本的图形模块

常用的方法：

imoprt turtle #导入库文件
showturtle() #显示当前的位置和方向
write(string) #绘制一个文本字符串
forward(int) #向箭头方向移动int个像素并绘制直线
right(int) #转向int度数
color(string) #设置颜色
goto(int,int) #移到某个位置
penup() #抬起笔
pendown() #放下笔
circle(int) #绘制半径为int的圆
done() #绘制完毕

简化书写过程：import turtle as t

示例：

绘制三角形

import turtle as t
t.pensize(10)  # 画笔宽度
t.right(60)
t.forward(100)  #向箭头方向移动 100 个像素并绘制直线
t.right(120)   #转向 120 度数
t.forward(100)
t.right(120)
t.forward(100)
t.done()  #绘制完毕

绘制五角星

import turtle as t
t.pensize(10)   # 画笔宽度
t.color("red")
t.right(72)
t.forward(100)
t.right(144)
t.forward(100)
t.right(144)
t.forward(100)
t.right(144)
t.forward(100)
t.right(144)
t.forward(100)
t.done()

绘制五环

import turtle # 画布中心坐标为（0,0）
turtle.pensize(10) # 画笔宽度
turtle.color("blue")
turtle.penup()
turtle.goto(-110, -25)
turtle.pendown()
turtle.circle(45)
turtle.color("black")
turtle.penup()
turtle.goto(0, -25)
turtle.pendown()
turtle.circle(45)
turtle.color("red")
turtle.penup()
turtle.goto(110, -25)
turtle.pendown()
turtle.circle(45)
turtle.color("yellow")
turtle.penup()
turtle.goto(-55, -75)
turtle.pendown()
turtle.circle(45)
turtle.color("green")
turtle.penup()
turtle.goto(55, -75)
turtle.pendown()
turtle.circle(45)
turtle.done()

冰墩墩：

import turtle

turtle.title('PythonBingDwenDwen')

turtle.speed(10)  # 速度

# 左手
turtle.penup()  #penup() #抬起笔
turtle.goto(177, 112) #goto(int,int) #移到某个位置
turtle.pencolor("lightgray")
turtle.pensize(3)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()  #pendown() #放下笔
turtle.setheading(80)
turtle.circle(-45, 200)
turtle.circle(-300, 23)
turtle.end_fill()

# 左手内
turtle.penup()
turtle.goto(182, 95)
turtle.pencolor("black")
turtle.pensize(1)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.setheading(95)
turtle.pendown()
turtle.circle(-37, 160)
turtle.circle(-20, 50)
turtle.circle(-200, 30)
turtle.end_fill()
# 轮廓
# 头顶
turtle.penup()
turtle.goto(-73, 230)
turtle.pencolor("lightgray")
turtle.pensize(3)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(20)
turtle.circle(-250, 35)
# 左耳
turtle.setheading(50)
turtle.circle(-42, 180)
# 左侧
turtle.setheading(-50)
turtle.circle(-190, 30)
turtle.circle(-320, 45)
# 左腿
turtle.circle(120, 30)
turtle.circle(200, 12)
turtle.circle(-18, 85)
turtle.circle(-180, 23)
turtle.circle(-20, 110)
turtle.circle(15, 115)
turtle.circle(100, 12)
# 右腿
turtle.circle(15, 120)
turtle.circle(-15, 110)
turtle.circle(-150, 30)
turtle.circle(-15, 70)
turtle.circle(-150, 10)
turtle.circle(200, 35)
turtle.circle(-150, 20)
# 右手
turtle.setheading(-120)
turtle.circle(50, 30)
turtle.circle(-35, 200)
turtle.circle(-300, 23)
# 右侧
turtle.setheading(86)
turtle.circle(-300, 26)
# 右耳
turtle.setheading(122)
turtle.circle(-53, 160)
turtle.end_fill()

# 右耳内
turtle.penup()
turtle.goto(-130, 180)
turtle.pencolor("black")
turtle.pensize(1)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(120)
turtle.circle(-28, 160)
turtle.setheading(210)
turtle.circle(150, 20)
turtle.end_fill()

# 左耳内
turtle.penup()
turtle.goto(90, 230)
turtle.setheading(40)
turtle.begin_fill()
turtle.pendown()
turtle.circle(-30, 170)
turtle.setheading(125)
turtle.circle(150, 23)
turtle.end_fill()

# 右手内
turtle.penup()
turtle.goto(-180, -55)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.setheading(-120)
turtle.pendown()
turtle.circle(50, 30)
turtle.circle(-27, 200)
turtle.circle(-300, 20)
turtle.setheading(-90)
turtle.circle(300, 14)
turtle.end_fill()

# 左腿内
turtle.penup()
turtle.goto(108, -168)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(-115)
turtle.circle(110, 15)
turtle.circle(200, 10)
turtle.circle(-18, 80)
turtle.circle(-180, 13)
turtle.circle(-20, 90)
turtle.circle(15, 60)
turtle.setheading(42)
turtle.circle(-200, 29)
turtle.end_fill()
# 右腿内
turtle.penup()
turtle.goto(-38, -210)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(-155)
turtle.circle(15, 100)
turtle.circle(-10, 110)
turtle.circle(-100, 30)
turtle.circle(-15, 65)
turtle.circle(-100, 10)
turtle.circle(200, 15)
turtle.setheading(-14)
turtle.circle(-200, 27)
turtle.end_fill()

# 右眼
# 眼圈
turtle.penup()
turtle.goto(-64, 120)
turtle.begin_fill()
turtle.pendown()
turtle.setheading(40)
turtle.circle(-35, 152)
turtle.circle(-100, 50)
turtle.circle(-35, 130)
turtle.circle(-100, 50)
turtle.end_fill()
# 眼珠
turtle.penup()
turtle.goto(-47, 55)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(25, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-45, 62)
turtle.pencolor("darkslategray")
turtle.fillcolor("darkslategray")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(19, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-45, 68)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(10, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-47, 86)
turtle.pencolor("white")
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(5, 360)
turtle.end_fill()

# 左眼
# 眼圈
turtle.penup()
turtle.goto(51, 82)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(120)
turtle.circle(-32, 152)
turtle.circle(-100, 55)
turtle.circle(-25, 120)
turtle.circle(-120, 45)
turtle.end_fill()
# 眼珠
turtle.penup()
turtle.goto(79, 60)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(24, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 64)
turtle.pencolor("darkslategray")
turtle.fillcolor("darkslategray")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(19, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 70)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(10, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 88)
turtle.pencolor("white")
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(5, 360)
turtle.end_fill()

# 鼻子
turtle.penup()
turtle.goto(37, 80)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.circle(-8, 130)
turtle.circle(-22, 100)
turtle.circle(-8, 130)
turtle.end_fill()

# 嘴
turtle.penup()
turtle.goto(-15, 48)
turtle.setheading(-36)
turtle.begin_fill()
turtle.pendown()
turtle.circle(60, 70)
turtle.setheading(-132)
turtle.circle(-45, 100)
turtle.end_fill()

# 彩虹圈
turtle.penup()
turtle.goto(-135, 120)
turtle.pensize(5)
turtle.pencolor("cyan")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-165, 150)
turtle.circle(-130, 78)
turtle.circle(-250, 30)
turtle.circle(-138, 105)
turtle.penup()
turtle.goto(-131, 116)
turtle.pencolor("slateblue")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-160, 144)
turtle.circle(-120, 78)
turtle.circle(-242, 30)
turtle.circle(-135, 105)
turtle.penup()
turtle.goto(-127, 112)
turtle.pencolor("orangered")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-155, 136)
turtle.circle(-116, 86)
turtle.circle(-220, 30)
turtle.circle(-134, 103)
turtle.penup()
turtle.goto(-123, 108)
turtle.pencolor("gold")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-150, 136)
turtle.circle(-104, 86)
turtle.circle(-220, 30)
turtle.circle(-126, 102)
turtle.penup()
turtle.goto(-120, 104)
turtle.pencolor("greenyellow")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-145, 136)
turtle.circle(-90, 83)
turtle.circle(-220, 30)
turtle.circle(-120, 100)
turtle.penup()

# 爱心
turtle.penup()
turtle.goto(220, 115)
turtle.pencolor("brown")
turtle.pensize(1)
turtle.fillcolor("brown")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(36)
turtle.circle(-8, 180)
turtle.circle(-60, 24)
turtle.setheading(110)
turtle.circle(-60, 24)
turtle.circle(-8, 180)
turtle.end_fill()

# 五环
turtle.penup()
turtle.goto(-5, -170)
turtle.pendown()
turtle.pencolor("blue")
turtle.circle(6)
turtle.penup()
turtle.goto(10, -170)
turtle.pendown()
turtle.pencolor("black")
turtle.circle(6)
turtle.penup()
turtle.goto(25, -170)
turtle.pendown()
turtle.pencolor("brown")
turtle.circle(6)
turtle.penup()
turtle.goto(2, -175)
turtle.pendown()
turtle.pencolor("lightgoldenrod")
turtle.circle(6)
turtle.penup()
turtle.goto(16, -175)
turtle.pendown()
turtle.pencolor("green")
turtle.circle(6)
turtle.penup()

turtle.pencolor("black")
turtle.goto(-16, -160)
turtle.write("BEIJING 2022", font=('Arial', 10, 'bold italic'))
turtle.hideturtle()

turtle.done()

2.1.9 常用命令

2.1.9.1 常用命令

type( ) ：返回的是变量的数据类型
ord( ) ：获取字符整数表示 ASCII值
chr( )：将编码转换为字符
id( )：查看内存地址
range(参数)：表示的是从0开始到参数的这个区间或者范围，前闭后开的区间
help( )：帮助查看命令使用方法

2.1.9.2 进制转换

输入十进制，转化为二进制、八进制、十六进制

bin：二进制（Binary system）
oct：八进制（Octal number system）
hex：十六进制（hexadecimal）

示例：

#输入一个十进制数，转换为二进制数、八进制、十六进制
num = int(input("请输入一个十进制的数："))
print("十进制数：",num)
print("二进制数：",bin(num))
print("八进制数：",oct(num))
print("十六进制数：",hex(num))

2.1.9.3

2.2 程序控制流程

顺序结构、选择结构（分支结构）、循环结构

2.2.1 顺序结构

从上到下，从左到右的顺序

程序设计思路：

变量初始化（名称、个数、初始值）
输入 input
处理算法
输出 print

例1：输入一个十进制数，转换为二进制数、八进制、十六进制

#输入一个十进制数，转换为二进制数、八进制、十六进制
num = int(input("请输入一个十进制的数："))
print("十进制数：",num)
print("二进制数：",bin(num))
print("八进制数：",oct(num))
print("十六进制数：",hex(num))

2.2.2 选择结构

python 是 强缩进 语言

2.2.2.1 单分支

语法规则：

if 条件:
    # 缩进  python 是一门强缩进语言
    # 添加满足执行的代码

单分支结构示例：

age = 20
if age >= 18:
    print("您的年龄是：",age)
    print("恭喜你已成年")

注意：缩进（Tab）和空格的区别，缩进和空格不能混合使用

IndentationError:unindent does not match any outer indentation level：表示缩进有问题
缩进：Indentation

2.2.2.2 双分支

流程图：
在这里插入图片描述
语法规则：

if 条件:
    #满足条件所执行的代码
else:
    #不满足条件时所执行的代码

示例：

age = 17
if age >= 18:
print("您的年龄是：",age)
print("恭喜您，您已经成年了！！！！！")
else:
print("您的年龄是：",age)
print("很抱歉，您还是未成年！！！！！")

2.2.2.3 多分支

多分支（三分支），不一定只有三个分支
语法规则：

if 条件1:
    # 条件1满足的时候执行的代码
elif 条件2:
    # 条件2满足的时候执行的代码
elif 条件3:
    # 条件3满足的时候执行的代码
‘’‘’‘’
elif 条件n:
    # 条件n满足的时候执行的代码    
[ else:
#以上条件均不满足的时候执行的代码
]

[ ] ：可写可不写的部分，根据实际的情况
示例：

age = 17
if age >= 18:
print("您的年龄是：",age)
print("恭喜您，您已经成年了！！！！！")
elif age >= 12:
print("您的年龄是：",age)
print("青少年")
else:
print("您的年龄是：",age)
print("小学生！！！！！")

注意：代码时从上到下的顺序进行执行的，但凡满足某个条件的时候，会执行条件满足的代码，就不会继续往下执行了，所以要考虑代码的严谨性（逻辑上）

2.2.3 循环结构

补充：字符串的拼接方式

+str(其他类型)进行拼接
可以使用逗号
%s占位符
使用{}进行补充，使用字符串中format（）进行拼接

#实现1+2+3+4+5
num = 1 + 2 + 3 + 4 + 5
print("1+2+3+4+5=",num)
print("1+2+3+4+5="+str(num))
print("1+2+3+4+5=%s"%(num))
print("1+2+3+4+5={}".format(num))

print("{}+{}={}".format(num1,num2,(num1+num2)))

2.2.3.1 while

语法结构：

while 条件:
       # 缩进
       # 循环体

注意：while True: # 死循环

index：指数

打印1~100：

index = 1
while index <= 100:
print(index)
index += 1

打印1~100的和：

index = 1
sum = 0
while index <=100:
	sum = sum + index
	index += 1
print(sum)

练习：
1、计算100以内所有奇数（index % 2 == 1）的和

index = 1
sum = 0
while index < 100:
	if index % 2 == 1
		sum += index
	index += 1
print(sum)
# 或者
index = 1
sum = 0
while index <=100:
	sum = sum + index
	index += 2
print(sum)

2、打印以下图案

*
**
***
****
*****
******

layer = eval(input("请你输入你要打印的行数:"))
index = 1
while index <= layer:
	j = 1 #控制每一行 * 号的个数
	while j <= index:
		print("*",end=" ") # end变为了空
		j += 1
	print() # 换行
	index += 1

print(“*”)会打印一个 * 号然后换行

print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
end=‘\n’ ：表示默认取值 \n，即换行
在这里插入图片描述

3、打印九九乘法表

i = 1
while i <= 9:
	j = 1
	while j <= i:
		print("%s * %s = %s"%(i,j,(i*j)),end=" ")
		j += 1
	print()
	i += 1

优化：

i = 1
while i <= 9:
	j = 1
	while j <= i:
		res = i * j
		if res < 10:
			print("%s * %s = %s "%(i,j,(i*j)),end="  ")
		else:
			print("%s * %s = %s "%(i,j,(i*j)),end=" ")
		j += 1
	print()
	i += 1

for i in range(1,10):
    j = 1
    for j in range(1,i + 1):
        result = i * j
        if result < 10:
	        print("%d * %d = %d"%(j,i,result),end="  ")
        else:
            print("%d * %d = %d"%(j,i,result),end=" ")
        if j == 9:
            break
    print()

4、实现两个数的交换（用户输入两个数，存储在两个变量里面的，交换两个变量的值）

方法一：取中间变量法临时变量法（浪费内存空间）
方法二：求和法
方法三：异或交换法（python独有的）寄存器的概念

实现两个数的交换（用户输入两个数，存储在两个变量里面的，交换两个变量的值）

num1 = int(input("请输入第一个数："))
num2 = int(input("请输入第二个数："))
print("交换前：num1=%s num2=%s"%(num1,num2))

#方法一：取中间变量法 临时变量法（浪费内存空间）
temp = num1
num1 = num2
num2 = temp
print("交换后：num1=%s num2=%s"%(num1,num2))
# 变量是存储在内存里面，会在内存栈里面开辟一个空间存储这个变量，取一个 temp ，即在内存里开辟了一个空间存储了这个值，浪费了内存空间

#方法二：求和法
num1 = num1 + num2 # num1 = 55 = 23 + 32
num2 = num1 - num2 # num2 = 55 - 32 = 23
num1 = num1 - num2 # num1 = 55 - 23 = 32
print("交换后：num1=%s num2=%s"%(num1,num2))
# 内存空间里只有num1和num2这两个临时变量，并没有开辟新的空间，没有浪费内存空间

#方法三：异或交换法 （python独有的） 寄存器的概念
num1,num2 = num2,num1
print("交换后：num1=%s num2=%s"%(num1,num2))

2.2.3.2 for 循环

for循环、for in 的结构用来遍历容器
列表：存储多个数据的一个容器
ls = [1,2,3,4,5]
for in：循环遍历容器中的每一个元素

语法结构：

for 变量 in 容器:
    #缩进
    #循环体

ls = [1,2,3,4,5,6,7,8,9] # 列表
for i in ls:
	print(i) 
# 打印出 ls 中的每个元素

结论：for in 循环时用来迭代（遍历）的容器的（可迭代的对象在python中是一种数据类型，列表元组集合字典）

引入 range 函数

range函数（全局函数）
range ：范围、区间

range（参数）：表示的是 从0开始 到参数的这个区间或者范围，前闭后开 的区间

>>> for i in range(10):
... print(i)
...
0
1
2
3
4
5
6
7
8
9

在这里插入图片描述

range（参数1，参数2）：从参数1到参数2的范围，前闭后开的区间

>>> for i in range(1,10):
... print(i)
...
1
2
3
4
5
6
7
8
9

range（参数1，参数2，step）：从参数1到参数2的范围，数据的变换是由step决定 的，默认的step是1， 前闭后开 的区间，step可以取负值

>>> for i in range(1,10,1):
... print(i)
...
1
2
3
4
5
6
7
8
9
>>> for i in range(1,10,2):
... print(i)
...
1
3
5
7
9
>>> for i in range(10,1,-1):
... print(i)
...
10
9
8
7
6
5
4
3
2

2.2.4 break 和 continue 关键字

break ：停止/终止循环

for i in range(101):
	if i == 50:
		break #停止/终止循环（50也不会打印出来）
	print(i)

continue ：跳过本次循环，继续下一次循环

for i in range(101):
	if i == 50:
		continue #跳过本次循环，继续下一次循环（只是不会打印50）
	print(i)

pass（关键字）：如果这一部分还没有想好什么操作，可以用pass进行代替不会影响整体代码的执行但是如果没有 pass 会报错

可以使用在任何地方（循环选择结构函数等）

for i in range(101):
	if i == 50:
		pass #如果这一部分还没有想好什么操作，可以用pass进行代替
	print(i)

补充：一个完整的循环结构
语法结构：

for 变量 in range(范围):
    #循环体
[else:
    循环正常结束后执行的代码
]

for i in range(101):
	if i == 50:
		pass
	print(i)
else:
	print("循环正常结束后执行的代码！！！！")
print("循环结束了！！！！")

在这里插入图片描述

for i in range(101):
	if i == 50:
		break
	print(i)
else:
	print("循环正常结束后执行的代码！！！！")
print("循环结束了！！！！")

在这里插入图片描述

2.2.5 练习

2.2.5.1 选择结构练习

在这里插入图片描述

"""思路:5个数字集合 累加每个集合里面的第一个数
步骤：
1.询问生日是否在集合1里面，在：累加
"""
set1 = "1\t3\t5\t7\n" \
       "9\t11\t13\t15\n" \
       "17\t19\t21\t23\n" \
       "25\t27\t29\t31\n"
set2 = "2\t3\t6\t7\n" \
       "10\t11\t14\t15\n" \
       "18\t19\t22\t23\n" \
       "26\t27\t30\t31\n"
set3 = "4\t5\t6\t7\n" \
       "12\t13\t14\t15\n" \
       "20\t21\t22\t23\n" \
       "28\t29\t30\t31\n"
set4 = "8\t9\t10\t11\n" \
       "12\t13\t14\t15\n" \
       "24\t25\t26\t27\n" \
       "28\t29\t30\t31\n"
set5 = "16\t17\t18\t19\n" \
       "20\t21\t22\t23\n" \
       "24\t25\t26\t27\n" \
       "28\t29\t30\t31\n"
day = 0
print(set1)
num = input("你的生日在不在ste1序列里面(y/n)")
if num == "y" or num == "Y":
    day += 1
print(set2)
num = input("你的生日在不在ste2序列里面(y/n)")
if num == "y" or num == "Y":
    day += 1
print(set3)
num = input("你的生日在不在ste3序列里面(y/n)")
if num == "y" or num == "Y":
    day += 1
print(set4)
num = input("你的生日在不在ste4序列里面(y/n)")
if num == "y" or num == "Y":
    day += 1
print("你的生日是：",day)

random模块，randon.randint：产生随机整数（闭区间）

"""
步骤：
1.提升用户输入一个两位数  user
2.电脑随机生成一个两位数  random模块 computer
3.将各自两位数进行拆分 个位a和十位b
4.usera == computera and userb == computerb 一等奖
5.usera == computerb and userb == computera 二等奖
6.usera == computera or usera == computerb or userb == computera or userb == computerb 三等奖
7.未中奖
"""
num = input("输入一个两位数：")
import random
computer = random.randint(10,99) #随机产生1个10-99的两位数（闭区间）
a = num % 10
b = num // 10
ca = computer % 10
cb = computer // 10
if a == ca and b == cb:
    print("一等奖")
elif a == cb and b == ca:
    print("二等奖")
elif a == ca or a == cb or b == ca or b == cb:
    print("三等奖")
else:
    print("未中奖，结果为：",computer)

random模块：可用 dir（random）查看 random 模块下的
在这里插入图片描述
在终端，首先进入python环境下，import，random模块，通过dir（）查看random下的方法，最后help（random.randint）查看使用方法

Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

关于模块random中randint方法的帮助:

随机(a, b)方法的随机。随机的实例
返回[a, b]范围内的随机整数，包括两个结束点。

2.2.5.2 循环结构练习

1、求0~100以内所有偶数的和

for i in range(2,101,2):
	print(i)

2、求0~100以内所有奇数的和

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

3、一个自然数与3的和是5的倍数，与3的差是6的倍数，这个自然数最小是多少？

index = 0
while True: # 死循环
	if (index + 3) % 5 == 0 and (index - 3) % 6 == 0 :
		print(index)
		break
	index += 1

4、在400~500之间求一个数，他被2除余1，被5除余3，被8除余1，这个数是多少？

5、打印三角形（等腰三角形）

~~~~*       第一行  4个空格（~） 1个*
~~~***      第二行  3           3
~~*****             2           5
~*******            1           7
*********           0           9
空格：总共行数 - 第i行
* 的个数： 2 * i - 1

layer = eval(input("请输入要打印的行数：")) # layer = 6
for i in range(1,layer+1): # 从 i (第一行)开始
	#计算每一行的空格数
	space_num = layer - i # 第一行的空格数为 6-1
	for j in range(0,space_num):
		print(" ",end=" ") # 一个一个的打印每一行的空格
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		print("*",end=" ")# 一个一个的打印每一行的 * 号
	print() # 一行的打印循环结束，换行

print(" * " ,end=" “)# 一个一个的打印每一行的 * 号
print(”*")：打印一个 * 号后换行

6、打印菱形

~~~~*        第一行 4个空格（~） 1个*
~~~***       第二行 3           3
~~*****        三   2 		    5
 *******       四	1 			7
*********	   五   0		    9
 ******* 	   六	1 			7
  *****		   七   2 		    5
   ***		   八   3 			3
    *          九   4           1 
                  下半部分*：总行数*2 - i*2 + 1

layer = eval(input("请输入要打印的行数："))
while layer%2 == 0 :
	layer = eval(input("请输入要打印的行数(奇数)："))
#上半部分 多打印了一行
#每一行
for i in range(1,layer//2+2):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		print("*",end=" ")
	print()
#下半部分
for i in range(layer//2,0,-1):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		print("*",end=" ")
	print()

错题：

layer = eval(input("请输入要打印的行数：")) # layer = 9
for i in range(1,layer // 2 + 2): # 从 i (第一行)开始
	#计算每一行的空格数
	space_num = layer // 2 + 2 - i # 第一行的空格数为 9 / 2 + 2 - 1 = 4
	for j in range(0,space_num):
		print(" ",end=" ") # 一个一个的打印每一行的空格
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		print("*",end=" ")# 一个一个的打印每一行的 * 号
	print() # 一行的打印循环结束，换行
for x in range(layer // 2 + 2,layer + 1):
	#计算每一行的空格数
	space_num = x - 4 # 第六行的空格数为 9-8
	for y in range(0,space_num):
		print(" ",end=" ") # 一个一个的打印每一行的空格
	#计算每一行的*的个数
	star_num = layer * 2 - 2 * x + 1
	for y in range(0,star_num):
		print("*",end=" ")# 一个一个的打印每一行的 * 号
	print() # 一行的打印循环结束，换行

7、打印空心菱形

判断是不是第一个和最后一个

layer = eval(input("请输入要打印的行数："))
while layer%2 == 0 :
	layer = eval(input("请输入要打印的行数(奇数)："))
#上半部分 多打印了一行
#每一行
for i in range(1,layer//2+2):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
	#判断是不是第一个和最后一个
		if j == 0 or j == star_num -1:
			print("*",end=" ")
		else:
			print(" ",end=" ")
	print()
#下半部分
for i in range(layer//2,0,-1):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		#判断是不是第一个和最后一个
		if j == 0 or j == star_num -1:
			print("*",end=" ")
		else:
			print(" ",end=" ")
	print()

      *
     * *
    *   *
   *     *
  *********
   *     *
    *   *
     * *
      *

判断是不是第一个和最后一个以及最后一行 i = layer // 2 + 1

layer = eval(input("请输入要打印的行数："))
while layer%2 == 0 :
	layer = eval(input("请输入要打印的行数(奇数)："))
#上半部分 多打印了一行
#每一行
for i in range(1,layer//2+2):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		#判断是不是第一个和最后一个以及最后一行 i = layer //2 + 1
		if j == 0 or j == star_num -1 or i == layer // 2 + 1:
			print("*",end=" ")
		else:
			print(" ",end=" ")
	print()
#下半部分
for i in range(layer//2,0,-1):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		#判断是不是第一个和最后一个
		if j == 0 or j == star_num -1:
			print("*",end=" ")
		else:
			print(" ",end=" ")
	print()

      *
     ***
    * * *
   *  *  *
  *********
   *  *  *
    * * *
     ***
      *

layer = eval(input("请输入要打印的行数："))
while layer % 2 == 0 :
	layer = eval(input("请输入要打印的行数(奇数)："))
#上半部分 多打印了一行
#每一行
for i in range(1,layer//2+2):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		#判断是不是第一个和最后一个以及最后一行 i = layer //2 + 1 中间一列 j = star_num // 2
		if j == 0 or j == star_num -1 or i == layer // 2 + 1 or j == star_num // 2:
			print("*",end=" ")
		else:
			print(" ",end=" ")
	print()
#下半部分
for i in range(layer//2,0,-1):
	#计算每一行的空格数
	space_num = layer - i
		for j in range(0,space_num):
			print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		#判断是不是第一个和最后一个 中间一列 j = star_num // 2
		if j == 0 or j == star_num -1 or j == star_num // 2:
			print("*",end=" ")
		else:
			print(" ",end=" ")
	print()

      *
     ***
    * * *
   *  *  *
  *********
      *
      *  
      * 
      *

layer = eval(input("请输入要打印的行数："))
while layer%2 == 0 :
	layer = eval(input("请输入要打印的行数(奇数)："))
#上半部分 多打印了一行
#每一行
for i in range(1,layer//2+2):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		#判断是不是第一个和最后一个以及最后一行 i = layer //2 + 1 中间一列 j = star_num // 2
		if j == 0 or j == star_num -1 or i == layer // 2 + 1 or j == star_num // 2:
			print("*",end=" ")
		else:
			print(" ",end=" ")
			print()
#下半部分
for i in range(layer//2,0,-1):
	#计算每一行的空格数
	space_num = layer - i
	for j in range(0,space_num):
		print(" ",end=" ")
	#计算每一行的*的个数
	star_num = 2 * i - 1
	for j in range(0,star_num):
		#判断是不是 中间一列 j = star_num // 2
		if j == star_num // 2:
			print("*",end=" ")
		else:
			print(" ",end=" ")
	print()

引入random模块（产生随机整数）

random模块，random.randint：产生随机整数（闭区间）
在这里插入图片描述

"""
步骤：
1.提升用户输入一个两位数  user
2.电脑随机生成一个两位数  random模块 computer
3.将各自两位数进行拆分 个位a和十位b
4.usera == computera and userb == computerb 一等奖
5.usera == computerb and userb == computera 二等奖
6.usera == computera or usera == computerb or userb == computera or userb == computerb 三等奖
7.未中奖
"""
num = input("输入一个两位数：")
import random
computer = random.randint(10,99) #随机产生1个10-99的两位数（闭区间）
a = num % 10
b = num // 10
ca = computer % 10
cb = computer // 10
if a == ca and b == cb:
    print("一等奖")
elif a == cb and b == ca:
    print("二等奖")
elif a == ca or a == cb or b == ca or b == cb:
    print("三等奖")
else:
    print("未中奖，结果为：",computer)

Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

关于模块random中randint方法的帮助:

随机(a, b)方法的随机。随机的实例
返回[a, b]范围内的随机整数，包括两个结束点。

2.3 内置容器

2.3.1 容器的概念

容器的概念？为什么学习容器

容器：可以存放多个数据（元素）的数据类型（引用数据类型复合数据类型）
补充变量无法存储多个或者大量的数据的缺陷

python 中提供的容量：列表、集合、元组、字典

列表list：ls = [ ]
集合set：s = { }
元组tuple：t =( )
字典dict：d = { }

2.3.2 列表：list

线性表：底层都是基于链表的数据结构去实现（常见的线性表：数组、栈、队列、链表）
python 中没有数组（特点：查询速度比较快（因为都是连续的），增删改的速度比较慢）

栈：先进后出，后进先出
队列：先进先出，后进后出
链表：单向链表和双向链表

python 中的列表是基于链表（双向链表）实现的
创建列表：
弱数据类型语言
ls = [ ]， ls = list([ ])， ls = list([1,2,3,4])
：ls = [ ]
[ ] 内如果是 int 类型，ls = [1,5,6,4，8]
如果是字符类型，ls = [“4”,“E”,“s”]

>>> ls = [1,2,3,4,5]
>>> type(ls)
<class 'list'>
>>> ls1 = list()
>>> type(ls1)
<class 'list'>
>>> ls1
[]
>>> ls2 = list([1,2,3,4,5,6])
>>> type(ls2)
<class 'list'>

dir（）：查看某个函数/模块里面的方法
list 使用方法：

>>> dir(list)
['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 
 'reverse', 'sort']

如何访问元素？

可以使用角标（下标索引）进行访问，注意下标是从0开始

>>> ls
[1, 2, 3, 4, 5]
>>> ls[0]
1
>>> ls[2]
3

如果下标超出了范围的话，会报错（抛出异常），可以通过下标去修改值，下标也可以为负数

>>> ls
[1, 2, 3, 7, 5]
# 下标也可以为负数，代表从后面开始倒着输出
>>> ls[-1]
5
>>> ls[-5]
1
>>> ls[-6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
# IndexError:列表索引超出范围

如何去计算列表的长度？

全局函数 len(容器)：返回的容器的长度

>>> help(len)
Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.
>>> ls
[1, 2, 3, 7, 5]
>>> len(ls)
5
>>> len(ls2)
6

如何遍历列表？？？？？

# for循环（更常用）
>>> ls
[1, 2, 3, 7, 5]
>>> for i in ls:
... print(i)
...
1
2
3
7
5
# whiel循环
ls = [1,2,3,4,5,6]
index = 0
while index < len(ls):
print(ls[index])
index += 1

2.3.2.1 append（向列表的尾部添加元素）

列表名.append(要添加的元素的值)
eg.

ls.append(4)：在 ls 列表的末尾加上元素 4

>>> help(ls.append)
Help on built-in function append:
append(object, /) method of builtins.list instance
Append object to the end of the list.
>>> ls
[1, 2, 3, 7, 5]
>>> ls.append("4") # 添加字符串‘4’
>>> ls
[1, 2, 3, 7, 5, '4']
>>> ls.append(4)
>>> ls
[1, 2, 3, 7, 5, '4', 4]

2.3.2.2 insert（向列表指定的位置添加元素）

列表名.insert(指定位置的角标，要添加的元素)
eg.

ls.insert(3,8)：在第四个元素前添加元素 8

>>> ls
[1, 2, 3, 7, 5, '4', 4]
>>> ls.insert(3,8)
>>> ls
[1, 2, 3, 8, 7, 5, '4', 4]

2.3.2.3 sort（列表排序）

列表名.sort(没有空格)
eg.

ls.insert( )

通常情况下，只能排序 int 类型的元素，默认是升序
如果元素是字母的话，排序的时候是依据ASCII码的值进行排序，要注意的是，列表里面的元素不能混合使用，不然不能排序

# 默认升序排序 int 类型元素

>>> ls1 = [2,3,1,7,6,4,8,9,5]
>>> ls1
[2, 3, 1, 7, 6, 4, 8, 9, 5]
>>> ls1.sort
<built-in method sort of list object at 0x0000023A6C854800>
>>> ls1.sort()
>>> ls1
[1, 2, 3, 4, 5, 6, 7, 8, 9]
# 元素是字母的话，排序的时候是依据ASCII码的值进行排序
>>> ls = ["A","b","c","D","B","a"]
>>> ls
['A', 'b', 'c', 'D', 'B', 'a']
>>> ls.sort()
>>> ls
['A', 'B', 'D', 'a', 'b', 'c']
# 列表里面的元素不能混合使用，不然不能排序
>>> ls = ["A","b","B",1,2,3,7,6,5,4]
>>> ls
['A', 'b', 'B', 1, 2, 3, 7, 6, 5, 4]
>>> type(ls)
<class 'list'>
>>> ls.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'

2.3.2.4 index（查找的是元素第一次在列表中出现的位置）

列表名.index(要查找的元素)
eg.

ls.index(1)：查找 1 在 ls 中角标是几

查找的是元素第一次在列表中出现的位置，如果没有这个元素则会抛出异常（报错）

>>> ls
['A', 'B', 'b', 1, 2, 3, 7, 6, 5, 4, 1, 2, 2]
>>> ls.index(1)
3
>>> ls.index(2)
4
# 如果没有这个元素则会抛出异常
>>> ls.index(8)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 8 is not in list

2.3.2.5 reverse（将元素的顺序进行翻转）

>>> ls
['A', 'B', 'b', 1, 2, 3, 7, 6, 5, 4, 1, 2, 2]
>>> ls.reverse()
>>> ls
[2, 2, 1, 4, 5, 6, 7, 3, 2, 1, 'b', 'B', 'A']

2.3.2.6 remove（通过元素进行移除元素）

通过元素进行移除元素，如果元素不存在会抛出异常（报错）

>>> ls
[2, 2, 1, 4, 5, 6, 7, 3, 2, 1, 'b', 'B', 'A']
>>> ls.remove(2)
>>> ls
[2, 1, 4, 5, 6, 7, 3, 2, 1, 'b', 'B', 'A']
>>> ls.remove(7)
# 元素不存在会抛出异常
>>> ls
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']
>>> ls.remove(8)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

2.3.2.7 count（统计元素在列表出现的次数）

>>> ls
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']
>>> ls.count(2)
2
>>> ls.count(5)
1
>>> ls.count(7)
0

2.3.2.8 clear（清除元素）

ls.clear()：清除列表中的所有元素

>>> ls1
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ls2
[1, 2, 3, 4, 5, 6]
>>> ls1.clear()
>>> ls1
[]
>>> ls2.clear()
>>> ls2
[]

2.3.2.9 copy（浅拷贝对象，不等价与=）

>>> ls
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']
>>> ls.copy()
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']
>>> ls1
[]
>>> ls1 = ls.copy()
>>> ls1
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']

2.3.2.10 extend（合并列表）

>>> ls1
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']
>>> ls
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']
>>> ls.extend(ls1)
>>> ls
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A', 2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']

2.3.2.11 pop（删除列表中的最后一个元素）

pop：删除列表中的最后一个元素，有返回值，返回的是删除的元素
如果要 删除指定位置的元素 ，可以通过 pop(i)，i 指定的是索引（下标）

>>> ls
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A', 2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A']
>>> ls.pop()
'A'
>>> ls
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A', 2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B']
>>> ls.pop()
'B'
>>> ls
[2, 1, 4, 5, 6, 3, 2, 1, 'b', 'B', 'A', 2, 1, 4, 5, 6, 3, 2, 1, 'b']
>>> ls.pop(2)
4
>>> ls
[2, 1, 5, 6, 3, 2, 1, 'b', 'B', 'A', 2, 1, 4, 5, 6, 3, 2, 1, 'b']

2.3.2.12 list 补充

创建列表：
ls = [ ]
[ ] 内如果是 int 类型，ls = [1,5,6,4，8]
如果是字符类型，ls = [“4”,“E”,“s”]

补充：

可以通过索引修改元素的值
list 里面的元素类型可以不同
list 里面可以包含（存放）另一个 list

>>> ls2
[]
>>> ls2 = [1,2,3,4,[1,2,3,4,5,6,7],5,6,7]
>>> ls2
[1, 2, 3, 4, [1, 2, 3, 4, 5, 6, 7], 5, 6, 7]
>>> type(ls2)
<class 'list'>
>>> ls2[4]
[1, 2, 3, 4, 5, 6, 7]
>>> ls2[4][4]
5
>>> ls2[4][4] = 8
>>> ls2
[1, 2, 3, 4, [1, 2, 3, 4, 8, 6, 7], 5, 6, 7]

2.3.3 集合：set（无序）

集合：set（哈希结构）
创建集合：
s = {1,2,3,4}
s = set() ，s = set({1,2,3,4,5})

>>> s = {1,5,63,2,7}
>>> s
{1, 2, 5, 7, 63}
>>> type(s)
<class 'set'>

集合的底层是哈希结构（hash）表去实现 ------- 集合是无序的、不能重复的，无序指的不是顺序的意思，涉及到 hash 的底层，不能重复的指的是元素是唯一的

# s[0] 是不支持的 会报错（集合无序性）
>>> s[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object is not subscriptable
>>> s = {1,2,3,1,2,3,1,2,3,1,2,3}
>>> s
{1, 2, 3}
>>> s = {3,2,1,4,6,5,7}
>>> s
{1, 2, 3, 4, 5, 6, 7}

>>> dir(set)
['add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update'
'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'union', 'update']

2.3.3.1 add（添加元素）

add ：添加元素，如果元素重复的话，不能添加，不会报错

>>> s
{1, 2, 3, 4, 5, 6, 7}
>>> s.add(8)
>>> s
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s.add(8)
>>> s.add(8)
>>> s.add(8)
>>> s
{1, 2, 3, 4, 5, 6, 7, 8}

2.3.3.2 difference（差集）

difference：差集（前 - 后）
union：并集

>>> s
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s1
{1, 2, 3, 4, 5, 8, 9}
>>> s.difference(s1) # 返回 difference 后 没有的元素
{6, 7}
>>> s1.difference(s)
{9}

2.3.3.3 intersection（交集）

>>> s
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s1
{1, 2, 3, 4, 5, 8, 9}
>>> s.intersection(s1)
{1, 2, 3, 4, 5, 8}
>>> s1.intersection(s)
>{1, 2, 3, 4, 5, 8}

2.3.3.4 unin（并集）

s.union(s1)返回集合s和集合s1的所有元素，不改变原集合的元素

>>> s
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s1
{1, 2, 3, 4, 5, 8, 9}
>>> s.union(s1)
{1, 2, 3, 4, 5, 7, 8, 9}
>>> s
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s1
{1, 2, 3, 4, 5, 8, 9}

2.3.3.5 update（更新集合，合并集合）

s.update(s1)：更新了 s 集合，把元素赋给原集合

>>> s
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s1
{1, 2, 3, 4, 5, 8, 9}
>>> s.update(s1) # 不会出现返回值
>>> s
{1, 2, 3, 4, 5, 6, 7, 8, 9}

2.3.3.6 discard（移除元素）

discard：移除元素，如果元素不存在的话，不会报错

>>> s
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> s.discard(9)
>>> s
{1, 2, 3, 4, 5, 6, 7, 8}
>>> s.discard(9)
>>> s.discard(9)
>>> s.discard(9)
>>> s
{1, 2, 3, 4, 5, 6, 7, 8}

2.3.4 元组：tuple（有序的，不可变类型）

元组是有序的，可通过下标去获取元素，下标可为负数，但不能修改元素
元组的特点：有序的，不可变类型
元组没有新增，修改，删除元素这3个方法
创建元组：
t =( )
t = (1,2,3,4)
t = tuple(( )) ，t = tuple((1,2,3,4))

>>> t = (1,2,3,4)
>>> t
(1, 2, 3, 4)
>>> type(t)
<class 'tuple'>
>>> tt = tuple() # 创建空的元组
>>> type(tt)
<class 'tuple'>
>>> tt
()
>>> ttt = tuple(1,2,3,4,5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: tuple expected at most 1 argument, got 5 # 类型错误
>>> ttt = tuple((1,2,3,4,5))
>>> ttt
(1, 2, 3, 4, 5)
>>> type(ttt)
<class 'tuple'>
# 通过下标查看元素
>>> t
(1, 2, 3, 4)
>>> t[0]
1
>>> t[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> t[0] = 3 # 元组一旦被建立，不可改变里面元素
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

>>> dir(tuple)
['count','index']

常见方法：count、index
元组是不可变类型（元组中元素一旦确定下来，就不能发生改变），但是元组中的元素可以是可变类型，那么元组就可变（可变指的是元组里面可变类型的元素是可变的，并不是元组本身发生改变）

# 元组中的元素可以是可变类型
>>> t = (1,2,3,[1,2,3,4,5],5,6)
>>> t
(1, 2, 3, [1, 2, 3, 4, 5], 5, 6)
>>> type(t)
<class 'tuple'>
>>> t[2] = 4
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t[3][2] = 7
>>> t
(1, 2, 3, [1, 2, 7, 4, 5], 5, 6)

面试题：a = (1) ,type(a)的返回类型是什么

>>> a = (1) #只有一个元素，会默认误输入了括号
>>> a
1
>>> type(a)
<class 'int'>
>>> a = ("a")
>>> a
'a'
>>> type(a)
<class 'str'>

如何定义只有一个元素的元组

>>> a = (1,)
>>> a
(1,)
>>> type(a)
<class 'tuple'>

2.3.5 字典：dict

字典存储是一个 键值对（key-value）形式存在的数据
创建字典：

       key     value    key  value 
d = {"name":"zhangsan","age":18}

d = { }
d = dict({ }) ，d = dict({“name”:“zhangsan”,“age”:18})

>>> d = {"name":"张三","age":18,"gender":"男"}
>>> d
{'name': '张三', 'age': 18, 'gender': '男'}
>>> type(d)
<class 'dict'>
>>> dd = dict()
>>> type(dd)
<class 'dict'>
>>> dd
{}
>>> ddd = dict({'name': '张三', 'age': 18, 'gender': '男'})
>>> ddd
{'name': '张三', 'age': 18, 'gender': '男'}
>>> type(ddd)
<class 'dict'>

如何访问字典中的值？？？？

通过key来访问对应的value，d[“name”],如果没有会抛出异常
可以通过key来修改value，字典对象[key] = 新value，字典对象新[key] = 新value 来添加新的键值对

>>> d["name"] # 通过key来访问对应的value
'张三'
>>> d["age"]
18
>>> d["sex"] # 如果没有会抛出异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'sex'
# 可以通过key来修改value，字典对象[key] = 新value
>>> d["name"] = "lisi"
>>> d
{'name': 'lisi', 'age': 18, 'gender': '男'}
# 添加新的键值对，字典对象新[key] = 新value
>>> d["address"] = "重庆" 
>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆'}

>>> dir(dict)
[ 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

2.3.5.1 get （通过Key获取value）

get：通过Key获取value，如果没有不会抛出异常，类似于字典对象[key]
键值对（“key = value”），顾名思义，每一个键会对应一个值。（每个键对应着相应的值，当按下相应的键时，就会输出相应的结果）
d.get(“sge”)：获取key（age）对应的value值（18）

>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆'}
>>> d.get("name")
'lisi'
>>> d.get("age")
18

2.3.5.2 keys（返回所有的键值)

keys（返回所有的键值)
d.keys()：返回字典 d 中的所有key值

>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆'}
>>> d.keys()
dict_keys(['name', 'age', 'gender', 'address'])

2.3.5.3 values（返回所有的 value）

values：返回所有的value
d.values()：返回字典 d 中的所有value值

>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆'}
>>> d.values()
dict_values(['lisi', 18, '男', '重庆'])

2.3.5.4 items（返回所有的键值对）

items ：返回所有的键值对
d.items()：返回字典 d 中的所有键值对

>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆'}
>>> d.items()
dict_items([('name', 'lisi'), ('age', 18), ('gender', '男'), ('address', '重庆')])

2.3.5.5 setdefault（设置默认值）

setdefault：设置默认值，默认的value

>>> d.setdefault("class")
>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆', 'class': None}
>>> help(d.setdefault)
Help on built-in function setdefault:

setdefault(key, default=None, /) method of builtins.dict instance
	Insert key with a value of default if key is not in the dictionary.
	Return the value for key if key is in the dictionary, else default.

2.3.5.6 pop（通过 key 来移除键值对）

pop：通过key来移除键值对，如果没有会抛出异常

>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆', 'class': None}
>>> d.pop("class")
>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆'}
>>> d.pop("class")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'class'

2.3.5.7 popitem（移除键值对）

popitem：移除键值对（按照 新进后出 的顺序进行移除），返回的是移除的键值对
即，从后往前移除

>>> d
{'name': 'lisi', 'age': 18, 'gender': '男', 'address': '重庆'}
>>> d.popitem()
('address', '重庆')
>>> d.popitem()
('gender', '男')

遍历字典

# 通过d.get(i)获取字典中的元素
>>> d
{'name': 'lisi', 'age': 18}
>>> for i in d:
... print(i,d.get(i))
...
name lisi
age 18

# 通过d[k]获取字典中的元素
>>> for k in d:
... print(k,d[k])
...
name lisi
age 18

>>> for k in d.keys(): # 通过循环返回键值，print(key，value)
... print(k,d[k])
...
name lisi
age 18

>>> for k,v in d.items():# 通过循环返回键对，k = key,v = value
... print(k,v)
...
name lisi
age 18

2.4 常见的排序

2.4.1 冒泡排序

先找最大值
先对整个列表的所有元素（i）遍历
再对 i 中元素进行遍历（相邻两两比较，把最大值放到最后）

请添加图片描述

list = [8,3,2,9,1,7,4,6,5] #len(list)= 9
for i in range(0,len(list)-1):  # 只需遍历第一个元素到倒数第二个元素，但range(0,len(list))也没错
    for j in range(0,len(list)-1-i):# 注意不要超出容器容量
        if list[j] >= list[j+1]:
            list[j],list[j+1] = list[j+1],list[j]
print(list)

2.4.2 选择排序

先找最小值

请添加图片描述

list = [8,3,2,9,1,7,4,6,5]
for i in range(0,len(list)): # 需要遍历列表中的每一个元素
    for j in range(i+1,len(list)): # 将 i 与 i 后面的每个元素进行比较，将最小值提到最前面
        if list[i] >= list[j]:
            list[i],list[j] = list[j],list[i]
print(list)

在这里插入图片描述

2.4.3 插入排序

请添加图片描述

list = [8,3,2,9,1,7,4,6,5]
for i in range(1,len(list)):
    for j in range(i,0,-1): # 第二次循环，j 值跟着 i 走，然后遍历 i 之前的所有元素，比较 j 与 j-1
        if list[j] < list[j-1]:
            list[j-1],list[j] = list[j],list[j-1]
print(list)

2.4.4 计数排序

找最大值和最小值
max = 9，min = 1
计算计数列表长度
max - min +1 = 9
偏移量 = 最小值=1

请添加图片描述

2.4.5 归并排序

2.4.6 桶排序

2.4.7

2.5 查找算法 —— 二分查找

二分查找：有序的列表中查找
n = 11

      1    2 3 4 5 6 7 8 9 10 11 12 13
角标：0     1 2 3 4 5 6 7 8 9 10 11 12 
    left                            right

定义左边的数 left = 0，right = len - 1
middle = (right + left) // 2
对比 n 是在列表的左半部分还是右半部分

list = [1,2,3,4,5,6,7,8,9,10,11,12,13]
n = 11
left = 0
right = len(list) - 1
while left <= right:
    middle = (left + right) // 2
    if n > list[middle]:
        left = middle + 1
    elif n < list[middle]:
        right = middle - 1
    else:
        print("存在")
        print(middle)
        break
else:
    print("不存在")

2.6 函数

2.6.1 函数的概述

在python中定义函数需要使用def关键字，依次写的是：函数名称、函数参数：函数体
如果函数有返回值的话需要使用return关键字进行返回

2.6.2 函数的定义和调用函数

语法规则：

def 函数名称([函数的参数]):
    #缩进 函数体
    [return 函数的返回值]

# 创建一个求绝对值的函数
def my_abs(x):
    if x >= 0:
        return x
    else:
        return x
    
print(my_abs(-99))

调用函数时，使用函数的名称进行调用
总结：如果函数在执行过程中，一旦执行了return,函数就会把结果进行返回，那如果没有return，函数的返回值是None

>>> def my_abs(x):
... if x >= 0 :
... return x
... else:
... return -x
...
>>> my_abs(-99)
99

函数在调用的过程中必须要注意的函数的参数类型和个数

>>> my_abs("a")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in my_abs
TypeError: '>=' not supported between instances of 'str' and 'int'
>>> my_abs(-99,99)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: my_abs() takes 1 positional argument but 2 were given

isinstance( ):函数来判断一个对象是否是一个已知的类型，类似 type()。

#创建一个求绝对值的函数
def my_abs(x):
if not isinstance(x,(float,int)):
raise TypeError("bad operand type")
if x >= 0:
return x
else:
return -x
print(my_abs("a"))

函数可以返回多个值

import math
def move(x,y,step,angle):
nx = x + step + math.sin(angle)
ny = y + step + math.cos(angle)
return nx,ny
# print(move(100,100,60,math.pi/6))
x,y = move(100,100,60,math.pi/6)
print(x,y)

函数可以返回多个值，但是返回的结果是一个元组

列表list：ls = [ ]
集合set：s = { }
元组tuple：t =( )
字典dict：d = { }

2.6.3 函数的分类

根据有无参数：有参函数、无参函数
根据有无返回值：有返回值函数无返回值函数
定义者分类：系统自定义的函数（abs、min、max）第三方定义的函数（公司、某个组织、自己定义）

2.6.4 函数的参数

函数的参数：位置参数、默认值参数、命名参数、可变参数、万能参数

#计算圆的周长
def get_circle_cal(r,pi):
return 2*pi*r
# r = eval(input("请输入圆的半径"))
# cal = get_circle_cal(r,3.14)
# print("半径是{}的圆的周长是{}".format(r,cal))
if __name__ == "__main__":
r = eval(input("请输入圆的半径"))
cal = get_circle_cal(r,3.14)
print("半径是{}的圆的周长是{}".format(r,cal))

总结：python中代码的入口不是main函数
python是一门脚本语言，从上到下的顺序执行
main作用：写在main函数中的代码不会被导入到其他模块中

2.6.4.1 位置参数

def get_circle_cal(r,pi):
return 2*pi*r

def power(x):
return x*x
def power1(x,n):
return x ** n

2.6.4.2 默认值参数

def power1(x,n=2):
return x ** n
print(power1(3,3))
print(power1(3))

注意：位置参数必须在前，默认值参数必须在后
如何这个函数有多个默认值参数，变化较小写在后面，变化较大的写在前面

def enroll(name,gender,age=18,city="重庆"):
print("name",name)
print("gender",gender)
print("age",age)
print("city",city)
# enroll("张三","男")
# enroll("李四","男",17)
print(enroll("李四","男",17))

def add_list(L=[]):
    L.append("END")
    return L
print(add_list())
print(add_list())
print(add_list())
print(add_list())

运行结果：

['END']
['END', 'END']
['END', 'END', 'END']
['END', 'END', 'END', 'END']

因为L指向的[ ]：是可变对象
注意：设置默认值参数的时候一定要 指向一个不可变对象
不可变对象：None

def add_list(L=None):
    if L is None:
        L = []
    L.append("END")
    return L
print(add_list())
print(add_list())
print(add_list())
print(add_list())

2.6.4.3 可变参数

可变参数用 * 来表示
可以传递实际的参数，或者可以不传递参数，可以传递0个、1个…任意个参数，底层是用元组的形式将参数进行封装起来

列表list：ls = [ ]
集合set：s = { }
元组tuple：t =( )
字典dict：d = { }

2.6.4.4 关键字参数

关键字参数也可以传递0个、1个或者任意个参数，底层是将参数封装成一个字典dict

def person(name,age,**kw):
	print("name:",name,"age:",age,"kw:",kw)
person("张三",18)
person("李四",20,city="重庆",gender="男")

dict = {"gender":"女","city":"北京"}
person("王五",20,**dict)

2.6.4.5 命名关键字参数

def person(name,age,**kw):
	if "gender" in kw:
		pass
	elif "city" in kw:
		pass
	print("name:",name,"age:",age,"kw:",kw)

需求：只能传入gender和city这两个参数，其他参数不能传入

def person(name,age,*,gender,city):
	print("name:",name,"age:",age,"gender:",gender,"city:",city)
# person("张三",20,job="XXX工程师")
person("张三",20,gender="男",city="重庆")

命名关键字参数可以取默认值

def person(name,age,*,gender,city="重庆"):
	print("name:",name,"age:",age,"gender:",gender,"city:",city)
person("张三",20,gender="男")

2.6.5 参数的组合

可以存在同一个函数中，但是一定有顺序
顺序：位置参数默认值参数可变参数命名关键字参数关键字参数

def f1(a,b,c=0,*args,**kw，*,d):

a,b：位置参数
c=0：默认值参数
*args：可变参数
**kw：关键字参数
*，d：命名关键字参数

def f1(a,b,c=0,*args,**kw)
    print("a=",a,"b=",b,"c:",c,"args=",args,"kw=",kw)
def f2(a,b,c=0,*,d,**kw):
    print("a=",a,"b=",b,"c:",c,"d=",d,"kw=",kw)
# f2(1,2,3,d=99,x=88)
args = (1,2,3,4)
kw = {"d":99,"x":88}
f1(*args,**kw)
args1 = (1,2,3)
kw1 = {"d":99,"x":88}
f2(*args1,**kw1)

输出：

a= 1 b= 2 c: 3 args= (4,) kw= {'d': 99, 'x': 88}
a= 1 b= 2 c: 3 d= 99 kw= {'x': 88}

def f1(a,b,c=0,*args,**kw):
	print("a=",a,"b=",b,"c=",c,"args=",args,"kw=",kw)
def f2(a,b,c=0,*,d,**kw):
	print("a=",a,"b=",b,"c=",c,"d=",d,"kw=",kw)
# f1(1,2,c=3)
# f1(1,2,3,"a","b")
# f1(1,2,3,"a",X=99)
# f2(1,2,3,d=99,x=88)
args = (1,2,3,4)
kw = {"d":99,"x":88}
f1(*args,**kw)
args1 = (1,2,3)
kw1 = {"d":99,"x":88}
f2(*args1,**kw1)

2.6.6 全局变量和局部变量

全局变量：
在python中，定义在py文件中的变量称为全局变量
特点：代码运行的过程中始终有效（不会被垃圾回收机制回收，除非手动的回收）

name = "张三" #name就是全局变量
name = None

局部变量：

定义在函数中的变量称为局部变量，当函数被垃圾回收机制回收的时候，局部变量也会被回收
局部变量的作用域仅限于函数的内部，在函数的外部是不能访问的，会报错

name = "张三" #name就是全局变量
# name = None
age = 18
def show(msg):
	gender = "男" #局部变量
	print(msg)
	print(gender)
	print(name) #在函数的内部是可以访问全局变量的
	print(age)
# print(show("哈哈哈哈哈哈哈"))
show("哈哈哈哈")
# print(gender)

总结：函数的外面不能访问函数内部定义的变量（局部变量）
反过来说，函数的内部是可以访问函数外面的变量（全局变量），但是不能改变全局变量。如果非要去改变全局变量的话，需要借助 global 这个关键字

name = "张三" #name就是全局变量
# name = None
age = 18
def show(msg):
	gender = "男" #局部变量
	global age
	print(msg)
	print(gender)
	print(name) #在函数的内部是可以访问全局变量的
	print(age)
	age += 1
	print(age)
# print(show("哈哈哈哈哈哈哈"))
show("哈哈哈哈")
# print(gender)

2.6.7 函数运行原理

为什么函数的内部不能去操作全局变量
函数是对象 ---- 对象存储在堆内存中
函数的调用的过程中，是一个压栈的过程，当函数调用完成之后，就会有弹栈的过程，弹栈之后就
会被垃圾回收机制回收
在这里插入图片描述

2.6.8 值传递和引用传递

值传递：传递的是值
在这里插入图片描述

x,y之间是不冲突的，因为add(x,y)中的x和y是局部变量（形参），而后面输入的input的x和y是实参，将实参传递给了形参
引用传递：传递的是对象

def info(fn,msg):
	fn()
	print(msg)
def print_msg():
	print("哈哈哈哈哈哈哈")
print(print_msg) #打印的是函数在内存中存储的内存地址 print_msg指的是函数本身
print(print_msg()) #None 因为函数没有返回值

def info(fn,msg):
fn()
print(msg)
def print_msg():
print("哈哈哈哈哈哈哈")
# print(print_msg) #打印的是函数在内存中存储的内存地址 print_msg指的是函数本身
# print(print_msg()) #None 因为函数没有返回值
#引用传递
info(print_msg,"呵呵呵呵呵呵呵呵呵")

2.6.9 匿名函数 —— lambda表达式

匿名函数：没有名字的函数，在python中是使用lambda这个表达式进行实现

function 函数名称（函数参数）{
函数体
代码块
return 返回值
}
function （函数参数）{
函数体
代码块
return 返回值
}

def 函数的名称（[函数的参数]）：
#缩进 代码块 函数体
return 函数的返回值
def （[函数的参数]）：
#缩进 代码块 函数体
return 函数的返回值
------- 不支持的

匿名函数函数：
lambda 参数：函数体如果函数有返回值进行返回，如果没有就不用返回

def sum_abc(a,b,c):
	return a+b+c
print(sum_abc(10,20,30))
sum_lambda = lambda a,b,c : a+b+c
print(sum_lambda(10,20,30))

无参的匿名函数

lambda_a = lambda : 100
print(lambda_a())
print(lambda_a)

一个参数：

lambda_b = lambda num : num * 10
print(lambda_b(10))

多个参数：

sum_lambda = lambda a,b,c : a+b+c
print(sum_lambda(10,20,30))

包含表达式：

lambda_c = lambda x : x if x % 2 == 0 else x + 1
print(lambda_c(6))
print(lambda_c(7))

总结：匿名函数是使用lambda表达式进行实现的，可以传入0个参数、1个参数、任意个参数，甚至可以包含表达式，但是函数返回值只有一个
lambda也可以作为一个参数进行传递

def sub_func(a,b,func):
	print("a=",a)
	print("b=",b)
	print("a-b=",func(a,b))
sub_func(100,1,lambda a,b : a - b ) # func = lambda a,b : a - b func(a,b)

运行结果：


lambda作为函数的返回值
```python
def run_func(a,b):
    return lambda c : a+b+c
return_func = run_func(1,1000)
print(return_func)
print(return_func(100))

运行结果：

<function run_func.<locals>.<lambda> at 0x00000227189701F0>
1101

2.6.10 偏函数

在python中，有时候我们需要调用某个函数的时候，如果将该函数的某个参数固定成某个值，可以使用偏函数

python中的functools模块中，有一个方法就是偏函数，partial()
import functools
functools.partial()
from functools

2.6.11 函数的递归

2.6.12 全局函数

链接: https://docs.python.org/zh-cn/3/library/functions.html#abs
round()：四舍五入，对于奇数来说，是标准的四舍五入，对于偶数来说，小于等于5的都舍去

2.7 字符串对象和切片操作

切片（slice）就是一种 截取索引片段 的技术，借助切片技术，我们可以十分灵活地处理序列类型的对象。

包括：正索和负索引两部分

2.7.1 字符串对象

字符串：由多个字符组成的串
字符：肉眼所能看到的符号
字节：肉眼看不到的
python中去定义字符串的方式：
单引号、双引号、三引号、str( )

2.7.2 字符串中常用的方法

>>> dir(s)
['capitalize', 'casefold', 'center', 'count', 'encode', 'endswith',
'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha',
'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric',
'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower',
'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace',
'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split',
'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper',
'zfill']

2.7.2.1 capitalize（将字符串中的首字母变成大写）

capitalize ：将字符串中的首字母变成大写
encode：将字符串转换为字节

>>> s
'this is a string'
>>> s.capitalize()
'This is a string

2.7.2.2 center（居中显示）rjust、ljust

center（width, fillchar=’ '）：将字符串按照给定的长度进行居中显示，居中对齐
rjust：右对齐
ljust：左对齐

 >>> help(s.center)
Help on built-in function center:
center(width, fillchar=' ', /) method of builtins.str instance
Return a centered string of length width.
Padding is done using the specified fill character (default is a space).
>>> s.center(40)
' this is a string '
>>> s.center(40,"*")
'************this is a string************'
>>> s.rjust(40)
' this is a string'
>>> s.ljust(40)
'this is a string '
>>> s.ljust(40,"*")
'this is a string************************'
>>> s.rjust(40,"*")
'************************this is a string'

2.7.2.3 count （统计的字符在字符串中出现的次数）

count：统计的字符在字符串中出现的次数

 >>> s
'this is a string'
>>> s.count("s")
3
>>> s.count("is")
2

2.7.2.4

2.7.2.5

2.7.2.6

2.7.3 切片操作

切片：用来分隔可迭代对象（容器）
语法规则：

[i : i+n : m]
从序列的第i位索引起，向右取到后n位元素为止，按m间隔过滤

2.7.3.1

2.7.3.2

2.7.3.3

2.7.3.4

2.7.3.5 2.7.3.6 连续切片

2.7.3.7 切片的三个参数可以是表达式

>>> ls
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ls[2+1:3*2:7%3]
[3, 4, 5]
>>> ls[3:6:1]
[3, 4, 5]

面试题：

如果切片切割数据得时候，超出了下标的范围，会不会报错？

不会报错

在python中如何将列表反向输出？

2.8 内置模块

什么是模块？
模块的分类

根据创建者的角色可以进行分类：
系统的内置模块（math random os os.path uuid…）
第三方模块：使用之前需要自行进行安装

在线安装 pip install 模块名称 -i 国内镜像源（清华大学、豆瓣）
离线安装

自定义模块：

模块导入问题

import 关键字进行模块的导入
import 模块的名称
import 模块的名称 as 别名
from 包或者模块 import 子模块

2.8.1 math 模块

ceil：天花板的意思，向上取整
floor：向下取整
fabs：求绝对值，等价于全局函数abs
fmod：求模
pow：幂次方
sqrt：根号，开平

2.8.2 random 模块

randint：产生的是一个范围内的随机数[a,b]
random：产生的是[0,1)之间的随机数
randrange：产生的是一个范围内的随机数
choice：表示的是在序列（有序 set是无序的）随机筛选一个元素

Kendra919

关注

21
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
Python

Python一、准备工作1.1 软件安装1.1.1 python安装1.1.2 Visual Studio Code安装1.2 软件使用1.2.1 python 解释器1.2.2 编写第一个 python 程序1.3 python的由来二、python的基础部分2.1 基本数据类型2.1.1 变量2.1.2 标识符2.1.3 python 中的常量2.1.4 python中的关键字2.1.5 数据类型2.1.5.1 基本数据类型2.1.5.2 复合数据类型（引用数据类型）2.1.6 数据类型的转换2.1.6
复制链接

扫一扫