推荐使用Typora解锁全套,下载地址:https://www.typora.io/
Markdown是一种可以使用普通文本编辑器编写的标记语言,通过简单的标记语法,它可以使普通文本内容具有一定的格式。
使用word
撰写文档,有如下的弊端:
而假如单纯的使用txt,就没有一点格式了,
用html虽然既有格式又能加入版本控制,但是需要花费较多的时间在标签上,而且标签占了文档的较大百分比,不易阅读。
所以,最终的解决方案就是 Markdown ,作为一种轻量级的标记语言,能在非常短的时间内掌握。而且不仅可以用于写文档,还可以写博客、写简书、做一些随手笔记。Markdown文件以.md结尾,可以导出为html和PDF(需要使用的工具支持)。它是一种语法(个人认为是简化版的html),但是和html不同的是,各种解析器对其会有不同的表现。比如我的IDEA Markdown插件会把分割线显示成一条细灰线,Cmd Markdown则是显示一条虚线。所以建议保持使用一种Markdown工具和尽量使用标准语法。
# 一级标题
## 二级标题
### 三级标题
#### 四级标题
##### 五级标题
###### 最小只有六级标题
效果:
你复制粘贴即知晓!!!
**我被加粗了**
效果:
我被加粗了
*我倾斜了了*
效果:
我倾斜了了
> hello markdown!
效果:
hello markdown!
> hello markdown!
>> hello markdown!
效果:
hello markdown!
hello markdown!
```python
print('hello nick')
```
效果:
print('hello nick')
1. one
2. two
3. three
效果:
one
two
three
* one
* two
* three
效果:
one
two
three
---
效果:
第二行必须得有,并且第二行的冒号代表对齐格式,分别为居中;右对齐;左对齐):
段落==>表格==>插入表格
win键 + R --> CMD --> 回⻋
命令⾏结构
Microsoft Windows [版本 10.0.18363.1443] —> 版本
dos命令
指令 | 作用 |
---|---|
dir | 列出当前目录下的文件夹或者文件 |
md | 创建目录 |
rd | 删除目录 |
cd | 进入指定目录 |
cd… | 退回上一级目录 |
cd/ | 退回到根目录 |
del | 删除文件 |
exit | 退出dos命令 |
win+R | 快捷进入cmd |
where | 想查找某个可执行命令的绝对路径 |
进制也就是进位计数制,是人为定义的带进位的计数方法(有不带进位的计数方法,比如原始的结绳计数法,唱票时常用的“正”字计数法,以及类似的tally mark计数)。
对于任何一种进制—X进制,就表示每一位置上的数运算时都是逢X进一位。
将25转换为二进制数
解:25÷2=12 余数1
12÷2=6 余数0
6÷2=3 余数0
3÷2=1 余数1
1÷2=0 余数1
所以25=(11001)2
同理,
把十进制数转换为十六进制数时,将基数2转换成16就可以了.
例:将25转换为十六进制数
解:25÷16=1 余数9
1÷16=0 余数1
所以25=(19)16
例:将二进制数(000111010110)2转换为十六进制数.
解: 0001 1101 0110
1 D 6
所以(111010110)2=(1D6)16
转换时注意最后一组不足4位时必须加0补齐4位
8 bit | 1 byte | 字节 | byte |
1024 byte | 1 KB | 千字节 | Kilobyte |
1024 KB | 1 MB | 兆字节 | Megabyte |
1024 MB | 1 GB | 吉字节 | Giga byte |
1024 GB | 1 TB | 太字节 | Trillion byte |
1024 TB | 1 PB | 拍字节 | Peta byte |
1024 PB | 1 EB | 艾字节 | Exa byte |
1024 EB | 1 ZB | 泽字节 | Zetta byte |
1024 ZB | 1 YB | 尧字节 | Jotta byte |
1024 YB | 1 BB | 亿字节 | Bronto byte |
1024 BB | 1 NB | Nona Byte | |
1024 NB | 1 DB | Dogga Byte |
(输⼊ import this)
美胜于丑陋(Python 以编写优美的代码为⽬标)
明了胜于晦涩(优美的代码应当是明了的,命名规范,⻛格相似)
简洁胜于复杂(优美的代码应当是简洁的,不要有复杂的内部实现)
复杂胜于凌乱(如果复杂不可避免,那代码间也不能有难懂的关系,要保持接⼝简洁)
扁平胜于嵌套(优美的代码应当是扁平的,不能有太多的嵌套)
间隔胜于紧凑(优美的代码有适当的间隔,不要奢望⼀⾏代码解决问题)
可读性很重要(优美的代码是可读的)
即便假借特例的实⽤性之名,也不可违背这些规则(这些规则⾄⾼⽆上)
不要包容所有错误,除⾮你确定需要这样做(精准地捕获异常,不写except:pass ⻛格的代码)
当存在多种可能,不要尝试去猜测⽽是尽量找⼀种,最好是唯⼀⼀种明显的解决⽅案(如果不确定,就⽤穷举法)
虽然这并不容易,因为你不是 Python 之⽗(这⾥的 Dutch 是指 Guido )
做也许好过不做,但不假思索就动⼿还不如不做(动⼿之前要细思量)
如果你⽆法向⼈描述你的⽅案,那肯定不是⼀个好⽅案;反之亦然(⽅案测评标准)
命名空间是⼀种绝妙的理念,我们应当多加利⽤(倡导与号召)
搭建环境
Python的解释器
pip介绍
我们都知道python有很多的第三⽅库或者说是模块。这些库针对不同的应⽤,
发挥不同的作⽤。我们在实际的项⽬中肯定会⽤到这些模块。那如何将这些模
块导⼊到⾃⼰的项⽬中呢?
Python官⽅的PyPi仓库为我们提供了⼀个统⼀的代码托管仓库,所有的第三⽅
库,甚⾄你⾃⼰写的开源模块,都可以发布到这⾥,让全世界的⼈分享下载 。
python有两个著名的包管理⼯具easy_install和pip。在python 2中
easy_install是默认安装的,⽽pip需要我们⼿动安装。随着Python版本的提
⾼,easy_install已经逐渐被淘汰,但是⼀些⽐较⽼的第三⽅库,在现在仍然只
能通过easy_install进⾏安装。⽬前,pip已经成为主流的安装⼯具,⾃Python
2 >=2.7.9或者Python 3.4以后默认都安装有pip
pip -V
pip --version
pip install requests
pip install robotframework==2.8.7
pip uninstall requests
pip install SomePackage
pip install SomePackage==1.0.5 # 指定版本
pip install 'SomePackage>=1.0.6' # 最⼩版本
1 pip list
1 pip show package
pip freeze > D:\桌⾯\install.txt
pip install -r packages.txt
pip install pillow-4.2xxxxxxx.whl
的⽅式离线进⾏安装pip install SomePackage -i
https://pypi.douban.com/simplePyCharm 是 Python 最著名的集成开发环境 IDE 之⼀,由⼤名鼎鼎的 JetBrains 公司开发,如果你⽤过该公司其它产品,像 Intellij IDEA 或者 WebStorm,你将对 PyCharm 驾轻就熟,该公司旗下产品在功能布局及设置等⽅⾯都保持了很好的⼀致性。
IDE 是集成开发环境的英⽂缩写 (Integrated Development Environment),所谓集成开发环境就是将你在开发过程中所需要的⼯具或功能集成到了⼀起,⽐如:代码编写、分析、编译、调试等功能,从⽽最⼤化地提⾼开发者的⼯作效率。
IDE 通⽤特点:
⽬前 PyCharm 共有三个版本:Professional、Community 和 Edu 版。Community 和 Edu 版本是开源项⽬,它们是免费的。 Edu 版完整的引⽤了 Community 版所有的功
能。同时集成了⼀个python的课程学习平台,⽐较适合从未接触过的任何开发语⾔的⼩⽩。Professional 版是收费的,下⾯是 Profession 与 Community 版的对⽐,后者相对前者缺少很多重要功能,对于开发⼈员还是强烈建议选择 professional 版本,本课程中也将以 Professional 版本为例进⾏讲解。
在 IDE 市场也是⼤名鼎鼎, 主要是为科学计算⽽开发的。它是开源⼯具, 可运⾏在 Linux, Windows and Mac OS 上。
优点:
在查找和消解除代码性能链瓶颈⽅⾯⾮常⾼效;
可即时查看任何⽂档并修改⾃⼰的⽂档。
⽀持扩展插件。
缺点:
Eclipse 是 Java 语⾔的 IDE,PyDev 是其⼀个插件,安装后,可以在 Eclispe 中进⾏ Python 的开发⼯作。
优点:
"""
- 提供了代码语法⾼亮显示、解析器错误、代码折叠和多语⾔⽀持;
- 具有良好的界⾯视图,提供⼀个交互式控制台;
- ⽀持 CPython、Jython、Iron Python 和 Django,并允许在挂起模式下进⾏交互式测试。
缺点:
- 如果应⽤程序太⼤,使⽤多个插件,PyDev IDE 的性能会降低;
- 作为插件,在实际使⽤过程中不是很稳定。
"""
如果你的电脑上安装了 Python,同时也就安装了 IDLE。初学者可以利⽤它⽅便地创建、运⾏、测试Python 程序。
优点:
IDLE 纯粹在 Python 中开发,使⽤ Tkinter GUI ⼯具包,也是⼀个跨平台⼯具,可以⼯作在Windows, macOS 与 Linux 上;
它具有多窗⼝⽂本编辑器的良好功能,具有调⽤提示、智能缩进、撤消等许多功能;
它还⽀持对话框、浏览器和可编辑配置。
缺点:
也是在当今市场上流⾏和强⼤的 IDE,具有许多适合 Python 开发⼈员要求的功能, 可以⼯作在 Windows,macOS 与 Linux 上。 它是商业软件,Wing Personal 与 Wing 101 两个版本是为了学⽣与初学者的免费版本。
"""
优点:
1. 在试⽤版过期的情况下,Wing 为开发⼈员提供了⼤约 10 分钟的时间来迁移其应⽤程序;
2. 它有⼀个源浏览器,有助于显示脚本中使⽤的所有变量;
3. 功能强⼤的调试器,提供了⼀个额外的异常处理选项卡,可帮助开发⼈员调试代码。
缺点:
1. 在科学计算⽅⾯没有集成⼀些常⽤⼯具与库;
2. 商业版本功能强⼤,也意味占⽤内存⽐较⼤
"""
上⼀部分总结了其它 IDE 的优缺点, 相较其它产品,PyCharm 是功能最为完备,⽤户体验最好的IDE,适合⼤型项⽬的开发。 具体特性如下:
#!/usr/bin/env python# -*- coding: utf-8 -*-
# @Time : ${DATE} ${TIME}
# @Author : Jerry
# @File : ${NAME}.py
# @Software: ${PRODUCT_NAME}
常⻅问题总结
1 pip版本太低 输⼊升级指令 python -m pip install --upgrade pip 然后在去安装2 直接 pip install requests (不需要在后⾯加东⻄)3 或者通过换源⽅式去安装 pip install SomePackage -i https://pypi.douban.com/simple
1 多安装⼏次2 通过换源⽅式去安装 pip install SomePackage -i https://pypi.douban.com/simple
表达式
语句
程序
函数
例如:1+2,可以运行,但是没有输出结果
例如:判断语句,循环语句,比较语句等
一个程序就是相当于一个功能
win键 + R --> CMD --> 回⻋,在命令行里面输入:python回车,import keyword回车,再输入keyword.kwlist,就可以看到python保留字
我们首先来想想看你是怎么认识一个人的,今天来你会认识我,明天来你还会认识我。那你是不是记住我这个人的典型特征,比如我的名字、体重、身高…世间万物我们是不是都是这样去认识的?毫无疑问是的。既然人能识别世间万物,那么我们之前一直把计算机想象成人,那是不是说计算机也能识别世间万物呢?对的。计算机通过记录我们的状态认识我。这就是量的概念。
今天我可能180,明年我是不是可能就是185了(5cm不过分),那这种状态是不是会发生变化。
为什么要有变量
变量是计算机内存中的⼀块区域,存储规定范围内的值,值 可以改变,通俗的说变量就是给数据起个名字。
变量命名规则
注意 : 两个对象相等和两个对象是同⼀个对象是两个概念
既然知道了变量是什么玩意,那我们如何在Python中定义变量呢?
name = 'state'
age = 36
gender = 'male'
height = 176
weight = 140
从我们上面定义的变量可以看到,变量的组成分为以下三个部分:
name # 报错,无任何意义
age = 18
height = 185
print(age)
print(height)
# 打印出结果
18
185
对于每个变量,python都提供了这三个方法分别获取变量的三个特征,其中python的内置功能id(),内存地址不一样,则id()后打印的结果不一样,因为每一个变量值都有其内存地址,而id是用来反映变量值在内存中的位置,内存地址不同则id不同。
a= 10
print(a)
# 打印出来的结果是10
a="good"
b="moring"
print(a==b)
# 打印出来的结果是False
a=11
b=11
print(a is b)
# 打印出来的结果是 True
a=11
b=15
print(a is b)
# 打印出来的结果是 False
变量是变化的量,常量则是不变的量。python中没有使用语法强制定义常量,也就是说,python中定义常量本质上就是变量。如果非要定义常量,变量名必须全大写。
Age= 18
print(Age)
#打印出来的结果是18
Age=Age+1
Print(Age)
#打印出来的结果是19
如果是常量,那就没必要更改,所以python就只制定了一个规范,而没指定常量的语法,
因此常量也是可以修改的,但不建议。
类型 | 表示方法 |
---|---|
文本类型 | str |
数值类型 | int(整数型), float(浮点数), complex(复数) |
序列类型 | list(列表), tuple(元组), range(区间) |
映射类型 | dict(字典) |
集合类型 | set(集合), frozenset (冻结的集合) |
布尔类型 | bool(布尔) |
二进制类型 | bytes(字节), bytearray(新字节数组), memoryview (内存查看对象) |
\t 表示制表符
\n 表示换⾏符
\\ 表示反斜杠
\' 表示 '
\ '' 表示 ''
\(在行尾时)表示续行符
\e表示换页
"""长字符串内容"""'''长字符串内容'''
第⼆种格式化字符串 参数传递
第三种格式化字符串 占位符
len() 字符串的⻓度
max() 最⼤值
min() 最⼩值
str.split()分割字符串
str.join()拼接字符串
str.find()查找字符串
str.replace() 替换字符串
去空格
字符串⼤⼩写
s.upper() 全部⼤写
s.lower() 全部⼩写
s.isupper() 判断是不是⼤写
a = 10
b = 2
print("加法运算符", a + b)
print("减法运算符", a - b)
print("乘法运算符", a * b)
print("除法运算符", a / b)
a = 10
b = 3
print("// 整除", a // b)
print("% 取模", a % b)
c = 2
d = 3
print("** 幂运算", c ** d)
a1 = 9
print("开方计算", a1 ** 0.5)
赋值运算符的特殊写法 x = x + 3 其实是和 x += 3 是⼀样的
+= (x+= 3 相当于 x = x + 3 )
-= (x -= 3 相当于 x= x - 3 )
*= (x = 3 相当于 x = x 3 )
**= (x **= 3 相当于 x = x ** 3 )
/= (x /= 3 相当于 x = x/ 3 )
//= (x //= 3 相当于 x = x // 3 )
%= (x %= 3 相当于 x= x % 3 )
not可以对符号右侧的值进⾏⾮运算,对于布尔值,⾮运算会对其进⾏取反操作,True变False,False变True
0,空串,None, 还有一些表示空性的值都会转换为True, 其他的值都可以转换为False
下面几个代码运行结果都是True
a = not 0
b = not None
c = not {}
d = not []
print(a)
print(b)
print(c)
print(d)
a = 10 > 1 and 45.6 > 44
a1 = 1 > 10 and 45.6 > 44
a2 = 1 > 10 and 45.6 > 46
print(a)
print(a1)
print(a2)
a = 3 > 2 or 6 > 4
a1 = 3 > 2 or 4 > 6
a2 = 1 > 2 or 4 > 6
print(a)
print(a1)
print(a2)
print(10 and 20)
print(2 and 0)
print("" or "https://www.baidu.com")
print(18.5 or "https:www.baidu.com")
# 返回结果:200https://www.baidu.com18.5
a = int(input("Input a: "))
b = int(input("Input b: "))
print("a大于b") if a > b else (print("a小于b") if a < b else print("a等于b"))
a = "@@@"
# 第一种:
print("521", a, "嫁给我好吗?")
# 第二种%s
print("521 %s 嫁给我好吗?" % a)
# 第三种f""
print(f"521 {a} 嫁给我好吗?")
# 第四种
print("521 {} 嫁给我好吗?".format(a))
a = 10
b = 30
c = 20
res = a if a > b else b if b > c else c if c > a else a
print(res)
input("请输入:")
请输入是提示信息
if 条件表达式 :
代码块
else :
代码块
# 1. 定义布尔型变量 `has_ticket` 表示是否有车票
has_ticket = True
# 2. 定义整型变量 `knife_length` 表示刀的长度,单位:厘米
knife_length=int(input("请输入刀的长度:"))
# 3. 首先检查是否有车票,如果有,才允许进行 **安检**
if has_ticket:
print("有车票,可以开始安检..")
# 4. 安检时,需要检查刀的长度,判断是否超过 20 厘米
if knife_length>=20:
print("不允许携带 %d 厘米长的刀上车" % knife_length)
print("不允许上车")
else:
print("请上车")
#* 如果超过 20 厘米,提示刀的长度,不允许上车
#* 如果不超过 20 厘米,安检通过
# 5. 如果没有车票,不允许进门
else:
print("您要先买票啊")
if 条件表达式1
:代码块
elif 条件表达式2 :
代码块
elif 条件表达式3 :
代码块
........
else :
代码块
elif
和 else
都必须和 if
联合使用,而不能单独使用if
、elif
和 else
以及各自缩进的代码,看成一个 完整的代码块# if-elif-else语句一定会有且只有一个条件执行
value = 20000 # ?
if value >= 30000:
print('有钱任性')
elif value >= 20000:
print('有钱真好)
elif value >= 10000:
print(''哥也月薪上万了')
elif value >= 5000:
print('工资还说的过去')
elif value >= 2000:
print('能养活自己了')
else:
print('吃土我开心')
while 条件表达式 :
代码块
else:
代码块
案例:
a = input("请输入字符串:")
print(a)
while len(a) <= 5:
print("字符串长度是{}".format(len(a)), a)
a = input("输入错误,请输入字符串:")
else:
print("恭喜你输入正确", "字符串长度是{}".format(len(a)), a)
print("逆序", a[::-1])
i = 0
while i < 5:
j = 0
while j < 5:
print('*', end='')
j += 1
print()
i += 1
break和continue
break 可以⽤来⽴即退出循环语句,包括else语句
continue ⽤来跳过当次循环
i = 0
while i < 5:
i += 1
if i == 2:
break
# continue
print(i)
# print(b)
else:
# while循环的后继语句会在while循环正常执行完毕之后继续执行
print('循环正常执行完毕')
# 99乘法表
#代码一
row = 0
while row < 9:
row += 1
col = 0
while col < row:
col += 1
print("{}*{}={}".format(col, row, col * row), end="\t")
print()
#代码二
row = 1
while row <= 9:
col = 1
while col <= row:
print("{}*{}={}".format(col, row, col * row), end="\t")
col += 1
print()
row += 1
1.求1000以内所有的⽔仙花数
2.获取⽤户输⼊的任意数,判断其是否是质数?
3.猜拳游戏:
出拳 玩家:⼿动输⼊ 电脑:随机输⼊
判断输赢: 玩家获胜 电脑获胜 平局
方法一
for a in range(0, 9):
for b in range(0, 9):
for c in range(0, 9):
i = a * 100 + b * 10 + c
if a ** 3 + b ** 3 + c ** 3 == i and i > 100:
print(i, "是水仙花数")
方法二
for i in range(100, 1000):
a = str(i)
b = int(a[0])
c = int(a[1])
d = int(a[2])
if i == b ** 3 + c ** 3 + d ** 3:
print(i)
方法三:使用while
i = 100
while i <= 1000:
a = str(i)
b = int(a[0])
c = int(a[1])
d = int(a[2])
if i == b ** 3 + c ** 3 + d ** 3:
print(i)
i += 1
方法一:
a = int(input("请输入任意一个数字:"))
if a > 1:
for b in range(2, a):
if a % b == 0:
print("%s是合数" % a)
break
else:
print("%s是质数" % a)
else:
print("输入错误")
num = int(input("请输入一个数:"))
i = 2
while i < num:
if num % i == 0:
print("%s是合数" % num)
break
else:
print("%s是质数" % num)
break
# i += 1
import random
# | 1 | 石头
# | 2 | 剪刀
# | 3 | 布
# 1、石头1 胜 剪刀2
# 2、剪刀2 胜 布3
# 3、布3 胜 石头1
# 4、玩家=电脑 平局
while True:
player = int(input("请输入1,2,3三个数中一个数:"))
computer = random.randint(1, 3)
if (player == 1 and computer == 2) or \
(player == 2 and computer == 3) or \
(player == 3 and computer == 1):
print("玩家获胜")
elif (player == 2 and computer == 1) or \
(player == 3 and computer == 2) or \
(player == 1 and computer == 3):
print("电脑获胜")
elif player == computer:
print("咱心有灵犀,平局啦!")
if player == 0:
print("游戏停止")
break
print("玩家选择的拳头是%s -电脑出的拳是%s" % (player, computer))
print("输入0游戏停止")
方法二:
while True:
import random
player = int(input('请输入1,2,3:'))
computer = random.randint(1, 3)
# list1 = [(1, 3), (2, 1), (3, 2)]
if (player == 1 and computer == 3) or (player == 2 and computer == 1) or (player == 3 and computer == 2):
print('玩家获胜')
elif player == computer:
print('平局')
else:
print('电脑获胜')
1 语法
2 for 变量 in 序列(遍历的规则):
3 代码块
for i in range(1, 11):
print(i)
函数格式
range (start, stop[, step])
range(开始数据,结束数据,步长) 左闭右开型, 取头不取尾
开始数据可以省略,默认是从0开始, 结尾数据不可以省略,步长可以省略,默认为1
参数说明
while 表达式:
while 表达式:
代码块
代码块
for 变量 in 循环规则:
for 变量 in 循环规则:
代码块
代码块
a= 1
while a == 1 :
# 表达式永远为 true
b = int(input("输入一个数字 :"))
print ("你输入的数字是: ", b)
print ("Good bye!")
基本概念
序列的分类
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼']
print(list1[1:3])
# 根据索引值来做
print(list1[-2][2])
# print(list1[-100])
print(list1[::0])
a = [1, 2, 3] + [4, 5, 6]
a = [1, 2, 3] * [4, 5, 6]
a = [1, 2, 3] * 2
print(a)
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
print('海贼王' in list1)
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
print(len(list1))
a = [1, 2, 3]
print(max(a))
print(min(a))
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
print(list1.index('柯南'))
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
print(list1.count('海贼王'))
#在指定位置插入列表
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
list1[5] = '死神'
print(list1)
#del 删除
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
del list1[5]
print(list1)
# 通过切片的方式来修改列表
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
list1[4::] = 'abcd'
list1[4::] = 'a'
list1[4::] = 123
# 替换的数据必须是一个序列
print(list1[4::])
list1[0:0] = ['死神']
list1[::2] = 'abc'
#删除列表内容
list1[4:] = ''
list1[4:] = []
print(list1)
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
list1.append('死神')
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
list1.insert(4, '死神')
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
list1.extend(['死神', '机器猫'])
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
res = list1.pop(3)
print(res)
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼', '海贼王']
list1.remove('海贼王')
list1 = [1, 4, 3, 7, 5, 6, 8]
list1.reverse()
list1 = [1, 4, 3, 7, 5, 6, 8]
list1.sort(reverse=True)
print(list1)
list1 = ['柯南', '蜡笔小新', '火影忍者', '海贼王', '奥特曼']
# 将索引为奇数的元素删除 ['java','c','c#']
for item in list1:
if list1.index(item) % 2 != 1:
list1.pop(list1.index(item))
print(list1) # ['蜡笔小新', '火影忍者', '奥特曼']
这是因为列表用pop之后,后面的索引都会自动减1
a = [1, 2, 3, 4, 5, 6]
print("方法一:", a[::-1])
a.reverse()
print("方法二:", a)
a.sort(reverse=True)
print("方法三:", a)
import random
i = 9
while i > 0:
# 电脑随机数字computer
computer = random.randint(1, 10)
# user用户输入数字
user = int(input("请您输入1-10其中一个数字:"))
# 当用户中奖时再次随机更换电脑数字
while user == computer:
computer = random.randint(1, 10)
# 当用户不再中奖则跳出
if user != computer:
break
# i是计数器
i -= 1
str_1 = "您输入的数字是:{},开奖号码是:{}".format(user, computer)
str_2 = "您输入的数字是:{},开奖号码是:{},您9次机会已用完".format(user, computer)
if i == 0:
print(str_2)
else:
print(str_1)
方法二:
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
i = 1
while i < 10:
num = int(input("请输入1~10数字:"))
list1.remove(num)
print("猜错了,重新输入")
i += 1
print("正确答案是%s"%list1[0])
# 3. 有两个列表 lst1 = [11, 22, 33] lst2 = [22, 33, 44]获取内容相同的元素
list1 = [11, 22, 33]
list2 = [22, 33, 44]
for a in list1:
for b in list2:
a = int(a)
b = int(b)
if a == b:
print("list1位置:", list1.index(a), a, end="\t")
print("list2位置:", list2.index(b), b)
import random
teachers = ["赵老师", "钱老师", "孙老师", "李老师", "周老师", "吴老师", "郑老师", "王老师"]
room = [[], [], []]
for teacher in teachers:
room_num = random.randint(0, 2)
room[room_num].append(teacher)
print("房间1有这几位老师:", room[0])
print("房间2有这几位老师:", room[1])
print("房间3有这几位老师:", room[2])
while True:
# 获取用户名输入
username = input("请输入用户名:")
if username == 'quit':
break
# 校验用户名格式是否在6-20之间,查看用户名是不是以字母开头
if 6 > len(username) or len(username) > 20 or username[0] not in "abcdefghijklmnopqrstuvvwxyaABCDEFGHIJKLMNOPQRTSUVWXYZ":
print(username[0])
print("请输入有效的用户名,长度6-20,且必须以字母开头")
# print("请重新输入!!!")
continue
# 获取密码输入
passwd = input("请输入密码:")
# 校验密码格式6位,不能为纯数字,不能有空格
if len(passwd) < 6 or passwd.isdigit() or " " in passwd:
print("密码长度至少6位,不能为纯数字,不能有空格")
print("请重新输入")
# 如果不正确直接重新开始 ,所以使用continue
continue
print("校验成功!!,请输入quit退出。")
tuple1 = ()
print(type(tuple1), tuple1)
tuple1 = (1, True, None, [])
print(type(tuple1), tuple1)
print(tuple1[2])
tuple1 = 10
# 类型是int
tuple2 = 10,
# 类型是tuple
tuple3 = (10)
# 类型是int
tuple4 = (10,)
# 类型是tuple
print(type(tuple1))
print(type(tuple2))
print(type(tuple3))
print(type(tuple4))
结论:
修改元组:元组中的元素值是不允许修改的,但我们可以对元组进行连接组合
tuple1 = (1, 2.3)
tuple2 = ('a', 'b','c')
# 以下修改元组元素操作是非法的。
# tuple1[0] = 100
# 创建一个新的元组
tuple3 = tuple1 + tuple2
print (tuple3)
tuple1= ('a', 'b','c')del tuple1print(tuple1)
输出会报错:NameError: name ‘tuple1’ is not defined
tuple1 = (1, 2, 3, 4)
a, *b, c = tuple1 # *是一个通配符,一个元组里面通配符只能有一个
print(a)
print(b)
print(c)
字符串的拆包
s = 'sagdvdf'
a, *b, c = s # *是一个通配符,一个字符串里面通配符只能有一个
print(a)
print(b)
print(c)
list1 = [1, 2, 3, 4, 5]
a, *b, c = list1 # *是一个通配符,一个列表里面通配符只能有一个
print(a)
print(b)
print(c)
dict1 = {} # 创建空字典
dict1 = { 'name': '杨过', 'age': 18, 'gender': '男', 'skill': '黯然销魂掌',}
# dict.update() 将其他字典中的数据添加到这个字典当中来
dict1.update({'age': 1, '2': 2})
print(dict1)
#del 关键字删除
del dict1['1']
dict.popitem()
#不需要传递参数,会默认删除最后一个键值对
res = dict1.popitem()
# 返回值是删除的内容
print(res)
# dict.pop(key, [default])
res = dict1.pop('3', 'key不存在')
# 当不存在这个key的时候,会返回你设置的默认值
print(res)print(dict1)
import copy# 浅拷贝 :只能拷贝第一层的数据,不能拷贝第二层乃至更多层的数据独立出来
dict1 = {'name': 123, 'data': [1, 2, 3]}
dict2 = copy.copy(dict1)
dict1['name'] = 456
dict1['data'][1] = 456
print(dict1,dict2)
print(id(dict1), id(dict2))
输出结果:
{‘name’: 456, ‘data’: [1, 456, 3]} {‘name’: 123, ‘data’: [1, 456, 3]}
2064326258832 2064326258904
import copy
dict1 = {'name': 123, 'data': [1, 2, 3]}
dict2 = copy.deepcopy(dict1)
dict1['data'][1] = 456
print(dict1, dict2)
print(id(dict1['data']), id(dict2['data']))
print(id(dict1), id(dict2))
输出结果:
{‘name’: 123, ‘data’: [1, 456, 3]} {‘name’: 123, ‘data’: [1, 2, 3]}
2011805403272 2011805404232
2011802759312 2011803561632
dict1 = {
'name': '杨过',
'age': 18,
'gender': '男',
'skill': '黯然销魂掌',
}
# keys()
for k in dict1.keys():
print(dict1[k])
# values()
for v in dict1.values():
print(v)
# items()
for k, v in dict1.items():
print(k, '=', v)
# 添加元素
set.add(元素)
s = set()
s.add(1)
print(s)
set.update()
s.update({2, 3, 4, 5})
print(s)
# set.pop()
s={2, 3, 4, 5}
s.pop()
print(s)
# set.remove() 指定元素进行删除s={2, 3, 4, 5}s.remove(4)print(s)
set.clear()
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
# 集合的运算
# & 交集运算
print(s1 & s2)
# | 并集运算
print(s1 | s2 )
# - 差集运算
print(s1 - s2)
print(s2 - s1)
# ^ 亦或集
print(s1 ^ s2)
a = {1, 2, 4}
b = {1, 2, 3, 4, 5}
# <= 检查⼀个集合是否是另⼀个集合的⼦集
result = a <= b
# < 检查⼀个集合是否是另⼀个集合的真⼦集
result1 = a < b
# >=检查⼀个集合是否是另⼀个集合的超集
result2 = a >= b
# >检查⼀个集合是否是另⼀个集合的真超集
result3 = a >= b
print(result)
print(result1)
print(result2)
print(result3)
a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到python1/python2/python3
a = {"name": "123","data": {"result": [{"src": "python1"}, {"src": "python2"}, {"src": "python3"}]}}
b = a.get("data").get("result")for i in b:
print(i.get("src"))
a = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]list1=[]list2=[]dict1={}
for i in a:
if i>66:
list1.append(i)
elif i<66:
list2.append(i)
dict1["key1"]=list1
dict1["key2"]=list2
print(dict1)
语法
def 函数名([形参1,形参2,形参3…]):
代码块
def fun(a, b):
# 函数的参数就是相当于在函数内部定义了这两个变量, 但是并没有给他们赋值 ab就是一个形参(形式上的参数)
print(a + b)
fun(1, 2)
# 调用函数 ,如果有形参,那么必须传递实参(实际的参数)
def fun(a, b, c=20): # c=20 这个就是给c设置了一个默认值, 当设置了默认值之后,可以不传递这个参数的实参,那么这个时候这个参数的值就是这个默认值, 但是你如果传递了这个实参,那么就会覆盖掉这个默认值
print(a)
print(b)
print(c)
fun(1, 2, 3)
# 2. 关键字传参 可以不按照定义形参的顺序去传递实参,根据参数名进行传递参数
def fun(a, b, c=20):
print(a)
print(b)
print(c)
fun(a=1, c=3, b=2)
# 位置传参和关键字传参的混合使用: 位置传参必须放到关键字传参的前面
def fun(a, b, c=20):
print(a)
print(b)
print(c)
fun(1, b=2, c=3)
# 不定长参数: 不知道会接受几个实参,所以用不定长参数(形参)来接受实参
def fun(c, *args, b):
# *a就是不定长参数 当*a和位置传参混合使用的时候,位置参数一定要放到*a的前面
# 当*a和关键字传参一起使用的时候,关键字传参要放到后面去
# 顺序: 位置参数, *args, 关键字参数, **kwargs
print(*args)
print(args)
r = 0
for i in a:
r += i
print(r)
fun(2, 3, 4, 5, b=1)
四种参数传递排列顺序:位置,‘*’a,关键字,‘’** a
def fun(a, b, c):
print(a)
print(b)
print(c)
t = (1, 2, 3)
t = 'abc'
t = {'a': 1, 'b': 2, 'c': 3}
# fun(t[0], t[1], t[2])fun(**t) #使用**t可以对参数进行拆包
"""
1. 打印名⽚程序:输⼊姓名,电话号码,性别,最后打印出来名⽚
控制姓名⻓度为6-20
电话号码⻓度11
性别只能允许输⼊男或⼥
每⼀样信息不允许为空
"""
def card():
while True:
name = input("请输入姓名:")
if 6 < len(name) < 20:
break
else:
print("长度不对,请重新输入:")
while True:
Tel = input("请输入电话:")
if len(Tel) == 11:
if Tel.isdigit():
break
else:
print('格式不对,请重新输入')
# continue
while True:
gender = input("请输入性别:")
if gender == '男' or gender == '女':
break
else:
print('性别只有男女,请重新输入')
continue
return name, Tel, gender
name_card = card()
print(name_card)
"""
2. 使⽤函数求前20个斐波那契数列斐波那契数列:1,1,2,3,5,8,13,21...即: 起始
两项均为1,此后的项分别为前两项之和
"""
def fun(n):
fib = [1, 1]
for i in range(n):
fib.append(fib[-1] + fib[-2])
fibs = fib[i]
print(fibs)
fun(n=20)
"""
3. 编写⼀段代码,定义⼀个函数求1-100之间所有整数的和,并调⽤该函数打印
出结果
"""
def sum1(a, b):
r = 0
for i in range(a, b + 1):
r += i
print(r)
sum1(1, 100)
return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值
def fun(*args):
r = 0
for i in args:
r += i
print(r) # 这个结果仅仅只是让我们可以观测到这个r的值
# return 1
def fun1():
pass
# return 'agc' # return 后面跟的值会作为返回值返回出去, return后面的代码不在执行
return fun1
def fun(a, b):
"""
文档字符串
:param a:
:param b:
:return:
"""
pass
print()
help(print)
def fun():
# 声明此处的变量是全局变量
global a, b
a = 123
b = 223
print(a)
print(b)
def fun1():
print(a)
print(b)
fun1()
return a, b
print(fun())
print(a)
print(b)
a = 1
b = 2
c = 3
d = 4
# def fun():
# a = 2
# b = 4
# space = locals()
# print(space)
#
# pass
## fun()space = locals()
# space['abc'] = 123
print(space)
# 需求: 求10!的值
# 1! = 1
# 2! = 2*1
# 3! = 3*2*1
# print(1*2*3*4*5*6*7*8*9*10)
# 10!= 10*9! n! = n * (n-1)!
# 相当于数学里面的推导式
# 9! = 9*8!
# 。。。。。
# 1! = 1
def fun(n): # 求n! 的值
if n == 1:
return 1
return n * fun(n-1)
# n * (n-1) * fun(n-2) * 1
print(fun(10))
# 需求:求任意数的任意次幂的值
# m ** n m * m**(n-1)
# 10 ** 5
# 10 * 10 **4
# 10 ** 1 = 10
def fun(m, n): # 求m**n幂的值
if n == 1:
return m
return m * fun(m, n-1)
print(fun(10, 5))
print(fun(5, 5))
# 需求: 检测一个字符串是不是回文字符串
# 123456789987654321
# abcdefgfedcba
# 上海自来水来自海上
def fun1(s):
if len(s) < 2:
return True
elif s[0] != s[-1]:
return False
return fun1(s[1:-1])
print(fun1('abcdegfedcba'))
"""
1. ⽤函数实现⼀个判断⽤户输⼊的年份是否是闰年的程序
1.能被400整除的年份
2.能被4整除,但是不能被100整除的年份
以上2种⽅法满⾜⼀种即为闰年
"""
def fun(year):
if int(year) % 400 == 0 or (int(year) % 4 == 0 and int(year) % 100 != 0):
print("{}是闰年".format(year))
else:
print("{}是非闰年".format(year))
fun(input("请输入年份:"))
"""
2. 猴⼦吃桃问题(递归):
猴⼦第⼀天摘下若⼲个桃⼦,当即吃了⼀半,还不瘾,⼜多吃了⼀个。第
⼆天早上⼜将剩下的桃⼦吃掉⼀半,⼜多吃了⼀个。以后每天早上都吃了前
⼀天剩的⼀半零⼀个。到第10天早上想再吃时,⻅只剩下⼀个桃⼦了,求第
⼀天共摘了多少桃⼦?
桃子数n
第一天:n/2+1
第二天:(n-(n/2+1))/2+1 ==>n-1/2+1
"""
def fun1(n):
if n == 1:
return 1
return (fun1(n-1) + 1) * 2
print(fun1(10))
高阶函数的概念:
递归不是高阶函数,而是自己调用自己
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def fun(lst):
new_list = []
for i in list1:
if i % 2 == 0:
new_list.append(i)
return new_list
print(fun(list1))
# 上面这个不属于高阶函数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def fun(lst):
def fun1(n):
if n % 2 == 0:
return True
new_list = []
for i in lst:
if fun1(i):
new_list.append(i)
return new_list
print(fun(list1))
# 上面这个任然不属于高阶函数
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def fun1(n):
if n % 2 == 0:
return True
def fun2(n):
if n > 5:
return True
def fun(lst, fn): # lst=list1;fn=fun1
new_list = []
for i in lst:
if fn(i): # fn(i)就相当于fun1(i)
new_list.append(i)
return new_list
print(fun(list1, fun1)) # fun1是函数对象;把fun1可以改为fun2就直接变为大于5的数了
res = (lambda a, b: a + b)(1, 3)
print(res)
c = 1
d = 2
dict1 = {
'key': (lambda a, b: a + b)(c, d)
}
print(dict1)
# 需求:创建一个函数,赋值一个变量,要求再这个变量的基础上每次和不同的数字进行相加
def fun_out(num1):
def fun_inner(num2):
res = num1 + num2
return res
return fun_inner
fun_out(1) # fun_out(1)=fun_inner
r = fun_out(1) # r=fun_out(1)相当于fun_inner
# 到这一步函数没有执行完
r(2) # r(2)相当于fun_inner(2)
print(r(2))
# 到这一步函数已经执行完毕
print(r(3)) # 从这一步看出外部函数执行后没有被销毁
# 结论:闭包里面的外部函数的变量可以保证不被销毁;
# 如果闭包使用多了会造成内存溢出,所以闭包要慎用。
# 在闭包中修改外部函数的变量
def fun_out(num1):
def fun_inner(num2):
# 如果一定要修改,需要用到nonlocal
nonlocal num1 # 这行不添加的话结果就是1,1,增加这一行结果就是1,10
# nonlocal告诉解释器此处使用的不是本地的这个变量,而是外部变量
num1 = 10
res = num1 + num2
return res
print(num1)
fun_inner(1)
print(num1)
return fun_inner
# fun_out(1)
r = fun_out(1)
r(2)
程序的设计,要求开发对程序的扩展,要关闭对程序的修改
Python编码风格指南
# 请使⽤装饰器实现已存在的函数的执⾏所花费的时间
import time
def fun_out(old):
def fun_inner(*args, **kwargs): # 万能写法
begin = time.time()
print("程序开始执行了")
time.sleep(2)
print(old(*args, **kwargs))
time.sleep(2)
print("程序执行结束了")
time.sleep(2)
end = time.time()
print(end - begin)
return fun_inner
@fun_out
def power(a, b):
return a ** b
power(3, 5)
语法
1 [表达式 for 变量 in 旧列表]
2 [表达式 for 变量 in 旧列表 if 条件]
背景
创建⽣成器的⽅式
通过列表推导式的⽅式 -
# 方法一:类似于列表推导式
list2=[i for i in range(1,10) if i % 3==0]
print(list2)
gen = (i for i in range(1, 10) if i % 3 == 0)
print(gen)
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__()) # 超过迭代次数就会停止迭代并报错
# 或者
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
通过函数来构造生成器
# 方法二 通过函数来构造生成器
def fun():
i = 0
while True:
i += 1
return i #此时不是生成器
r = fun()
print(r)
def fun(): # 此时的fun就是一个生成器
i = 0
while True:
i += 1
yield i # 把return改为yield
r = fun()
print(r)
def fun1():
for i in range(1, 10):
yield i
r = fun1()
# print(next(r))
# print(next(r))
res = [i for i in r]
res1 = [i for i in r] #这个列表返回为空,因为生成器的特性,数据只能用一次
print(res)
print(res1)
list1 = [1, 2, 3, 4, 5, 6]
itr=iter(list1)
print(iter)
print(next(itr))
print(next(itr))
# __iter__自身 返回自己
# __next__下一个,拿到下一个
# 语法
class 类名([⽗类]):
pass
# 定义类:class 类名(): 类名遵循大驼峰方式来命名
# 实例对象的创建:实例对象=类名()
# 设置属性:实例对象.属性名称=“属性值”
# 方法创建:直接在类里面定义一个函数(函数,只是为了让大家理解,这里这么来称呼)
# 方法的使用:实例对象.方法名()
class MyClass:
name="周慧敏" # 公共属性
def sing(self): #公共方法
print("唱歌可好听了")
print(MyClass, type(MyClass))
mc = MyClass()
mc.name = "刘亦菲"
print(mc.name)
mc1 = MyClass()
print(mc1.name)
mc1.sing()
class Person:
name = "刘亦菲"
def speak(self):
print("大家好,我是{}".format(self.name))
p1 = Person()
p1.name = "刘亦菲"
p2 = Person()
p2.name = "周慧敏"
p1.speak()
p2.speak()
class person:
print("这个是类中的代码")
def __init__(self, name, age, weight):
self.name = name
self.age = age
self.weight = weight
def speak(self):
print(f"我的名字叫{self.name},我的年龄是{self.age}岁,体重是{self.weight}")
p1 = person("bill", 15, "30kg")
p2 = person("jason", 35, "70kg")
p1.speak()
# p2 = person("jason", 35, "70kg")
p2.speak()
出现封装的原因:我们需要⼀种⽅式来增强数据的安全性
封装是⾯向对象的三⼤特性之⼀
封装是指隐藏对象中⼀些不希望被外部所访问到的属性或⽅法
我们也可以提供给⼀个getter()和setter()⽅法是外部可以访问到属性
使⽤封装,确实增加了类的定义的复杂程度,但是它也确保了数据的安全
可以为对象的属性使⽤双下划线开头 __xxx。双下划线开头的属性,是对象
的隐藏属性,隐藏属性只能在类的内部访问,⽆法通过对象访问
其实隐藏属性只不过是Python⾃动为属性改了⼀个名字
_类名__属性名
例如 __name -> _Person__name
这种⽅式实际上依然可以在外部访问,所以这种⽅式我们⼀般不⽤。⼀般我
们会将⼀些私有属性以_开头
⼀般情况下,使⽤_开头的属性都是私有属性,没有特殊情况下不要修改私有
属性
如果在⼦类中有和⽗类同名的⽅法,则通过⼦类实例去调⽤⽅法时,会调⽤⼦类的⽅法
⽽不是⽗类的⽅法,这个特点我们称之为⽅法的重写(覆盖)
当我们调⽤⼀个对象的⽅法时:
会优先去当前对象中寻找是否具有该⽅法,如果有则直接调⽤
如果没有,则去当前对象的⽗类中寻找,如果⽗类中有则直接调⽤⽗类中的⽅法
如果没有,则去⽗类中的⽗类寻找,以此类推,直到找到object,如果依然没有找到就报错了
# __new__()⽅法
# __new__()⽅法⽤于创建与返回⼀个对象。在类准备将⾃身实例化时调⽤。
class Demo(object):
def __init__(self):
print("__init__")
def __new__(cls, *args, **kwargs):
print("__new__")
d = Demo()
"""
练习
以上代码打印输出的顺序?(C)
A.__init__,__new__
B.__init__
C.__new__
D.__new,__init__
"""
注意
对象创建执⾏顺序
class Demo(object):
def __init__(self):
print("__init__")
def __new__(cls, *args, **kwargs):
print("__new__")
return super().__new__(cls)
d = Demo()
"""
练习
以上代码打印输出的顺序?(D)
A.__init__,__new__
B.__init__
C.__new__
D.__new,__init__
"""
"""
注意
1.在创建对象时,⼀定要将对象返回,在会⾃动触发__init__()⽅法
2.__init__()⽅法当中的self,实际上就是__new__返回的实例,也就是该对象
__init__()与__new__()区别
__init__实例⽅法,__new__静态⽅法
__init__在对象创建后⾃动调⽤,__new__创建对象的⽅法
"""
单例模式介绍
单例模式实现
class single(object):
__isinstance = None
def __new__(cls, *args, **kwargs):
if cls.__isinstance is None:
cls.__isinstance = super().__new__(cls)
return cls.__isinstance
else:
return cls.__isinstance
a = single()
b = single()
print(id(a))
print(id(b))
__name__
默认等于字符串’__main__
’。__name__
属性值为__main__
的模块是主模块。⼀个程序中只有⼀个主模块try语句
try:
代码块(可能出现错误的语句)
except 异常类型 as 异常名:
代码块(出现错误以后的处理⽅式)
except 异常类型 as 异常名:
代码块(出现错误以后的处理⽅式)
except 异常类型 as 异常名:
代码块(出现错误以后的处理⽅式)
....
else:
代码块(没出错时要执⾏的语句)
finally:
代码块(是否出错该代码块都会执⾏)
try是必须的 else有没有都可以
except和finally⾄少有⼀个
file_name = 'demo.txt'
file_obj = open(file_name)
print(file_obj)
file_name = 'demo.txt'
# open打开文件
file_obj = open(file_name)
content = file_obj.read()
print(content)
# 关闭文件
file_obj.close()
file_obj.read()
# with 打开文件,不需要手动关闭
try:
with open(file_name) as f:
print(f.read())
except Exception as e:
print('文件不存在', e)
print(f.read())
file_name = 'demo.txt'
try:
with open(file_name, encoding='utf-8') as f:
print(f.read(7))
# help(f.read)
except Exception as e:
print('文件不存在', e)
file_name = 'demo.txt'
try:
with open(file_name, 'a', encoding='utf-8') as f:
f.write('我喜欢你,嫁给我吧!')
f.write('我愿意')
f.write(str(1111))
# help(f.read)
except Exception as e:
print('文件不存在', e)
From the distanceit looked like a skinny tube,
but as we got closer we could see it flesh out before our eyes.
It was tubular all right but fatter than we could see from far awa
y.
Furthermore, we were also astonished to notice that the building w
as really in two parts.
a pagoda sitting on top of a tubular one-story structure.
file_name = r'C:\Users\EDZ\Desktop\李荣浩 - 麻雀.mp3'
with open(file_name, 'rb') as f:
# print(f.read(100))
new_file = '123.mp3'
with open(new_file, 'wb') as file:
while True:
content = f.read(1024*100)
if not content:
break
file.write(content)