第一章 计算机基础
1.1 硬件
- 计算机基本的硬件由:CPU / 内存 / 主板 / 硬盘 / 网卡 / 显卡 等组成,只有硬件但硬件之间无法进行交流和通信。
- 人用程序通过编程语言解释器,指令操作系统,最终控制电脑硬件来做符合人们需求的过程
1.2 操作系统
操作系统用于协同或控制硬件之间进行工作,常见的操作系统有那些:
- windows
- linux
- centos 【公司线上一般用】
- mac
1.3 解释器或编译器
编程语言的开发者写的一个工具,将用户写的代码转换成010101交给操作系统去执行。
1.3.1 解释和编译型语言
解释型语言就类似于: 实时翻译,代表:Python / PHP / Ruby / Perl
编译型语言类似于:说完之后,整体再进行翻译,代表:C / C++ / Java / Go ...
1.4 软件(应用程序)
软件又称为应用程序,就是我们在电脑上使用的工具,类似于:记事本 / 图片查看 / 游戏
1.5 进制
对于计算机而言无论是文件存储 / 网络传输输入本质上都是:二进制(010101010101),如:电脑上存储视频/图片/文件都是二进制; QQ/微信聊天发送的表情/文字/语言/视频 也全部都是二进制。
进制:
- 2进制,计算机内部。
- 8进制
- 10进制,人来进行使用一般情况下计算机可以获取10进制,然后再内部会自动转换成二进制并操作。
- 16进制,一般用于表示二进制(用更短的内容表示更多的数据),一版是:\x 开头。
二进制 | 八进制 | 十进制 | 十六进制 |
---|---|---|---|
0 | 0 | 0 | 0 |
1 | 1 | 1 | 1 |
10 | 2 | 2 | 2 |
11 | 3 | 3 | 3 |
100 | 6 | 4 | 4 |
101 | 5 | 5 | 5 |
110 | 6 | 6 | 6 |
111 | 7 | 7 | 7 |
1000 | 10 | 8 | 8 |
1001 | 11 | 9 | 9 |
1010 | 12 | 10 | A |
1011 | 13 | 11 | B |
1100 | 14 | 12 | C |
第二章 Python入门
2.1.简介
Python是著名的“龟叔”(Guido van Rossum)在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言。
Python的哲学就是简单优雅,尽量写容易看明白的代码,尽量写少的代码。为我们提供了非常完善的基础代码库,覆盖了网络、文件、GUI、数据库、文本等大量内容,
2.1.1.Python适合开发哪些类型的应用呢?
- 云计算
- 机器学习
- 科学运算
- 自动化运维
- 自动化测试
- 爬虫
- 数据分析
- GUI图形化
- Web开发等
2.1.2.Python有哪些缺点呢?
- 运行速度慢,和C程序相比非常慢,因为Python是解释型语言
- 代码不能加密。如果要发布你的Python程序,实际上就是发布源代码
2.1.3.python种类
- Cpython(推荐)
Python的官方版本,使用C语言实现,使用最为广泛,CPython实现会将源文件(py文件)转换成字节码文件(pyc文件),然后运行在Python虚拟机上。 - Jyhton
Python的Java实现,Jython会将Python代码动态编译成Java字节码,然后在JVM上运行。 - IronPython
Python的C#实现,IronPython将Python代码编译成C#字节码,然后在CLR上运行。(与Jython类似) - PyPy
Python实现的Python,将Python的字节码字节码再编译成机器码。 - RubyPython、Brython 等
2.1.4.Python版本
目前主流的Python版本有两大分类:
- 2.x ,很多公司依然在用 2.7 版本,但Python官方在 2020 年将停止对 Python 2 的支持。
- 3.x ,功能更加强大且修复了很多2版本中不合适之处(推荐使用)
2.2 环境的安装
- 解释器:py2 / py3 (环境变量)
- 开发工具:pycharm
2.3 编码
2.2.1 编码基础
- ascii,英文,8位表示一个东西,2**8
- unicode ,万国码,32位表示一个东西,2**32
- utf-8,给unicode压缩,用尽量少的位数表示一个东西,以8个位为单位
- gbk,国标,只能中国人自己用, 一个中文用16位,两个字节表示。
- gb2312
2.2.2 python编码相关
对于Python默认解释器编码:
- py2: ascii
- py3: utf-8
如果想要修改默认编码,则可以使用:
# -*- coding:utf-8 -*-
注意:对于操作文件时,要按照:以什么编写写入,就要用什么编码去打开。
2.2.3 单位转化
8bit = 1byte
1024byte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024TB = 1EB
1024EB = 1ZB
1024ZB = 1YB
1024YB = 1NB
1024NB = 1DB
常⽤到TB就够了
2.4 输入输出
2.4.1.输入
python2和python3输入的语法不一样
- python2
>>> my_input = raw_input('666')
666
- python3
>>> my_input = input('666')
666
2.4.2.输出
python2和python3输出的语法不一样
- python2
>>> print "hello"
hello
- python3
>>> print('hello')
hello
2.5 变量
问:为什么要有变量?
为某个值创建一个“外号”,以后在使用时候通过此外号就可以直接调用。
变量就是一个会变化的量,加载到内存中,方便调用。不仅可以是数字,还可以是任意数据类型
2.5.1规范
- 变量名只能包含:字母/数字/下划线
- 数字不能开头
- 不能是python的关键字。 [‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]
2.5.2 建议
- 见名知意
>>> name='zzy'
>>> print(name)
zzy
>>> age=24
>>> print(age)
24
- 用下划线连接
>>> gao_qizhi='zzy'
>>> print(gao_qizhi)
zzy
- 变量名建议不使用拼音和中文
- 变量的要具有意义
- 变量名不要过长
- 变量名要区分大小写
2.6 常量
所谓常量就是不能变的变量,比如常用的数学常数π就是一个常量。在Python中,通常用全部大写的变量名表示常量
2.7 注释
- 单行注释,在一行的最开头添加"#"这个符号,解释器就会忽略这行代码
# print(hello)
- 多行注释,在代码块上一行,和最下面一行添加
'''
numb = 0
count = 1
while count < 100:
if count % 2 == 1:
numb -= count # total -= count
else:
numb += count # total += count
count += 1
print(numb)
'''
2.8 If条件语句
- if条件语句的基本结构
if语句的完整形式就是:
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
·······
else:
<执行4>
if语句执行有个特点,它是从上往下判断,如果在某个判断上是True,把该判断对应的语句执行后,就忽略掉剩下的elif和else。
2.9 while循环语句
2.9.1 while循环的格式
while 条件:
# 循环体
# 如果条件为真,那么循环则执行
# 如果条件为假,那么循环不执行
- 示例
1.输出 1-100 内的所有数字。
count = 0
while count < 100:
count = count + 1
print(count)
2.9.2 break关键字
作用:结束当前这个while循环
- 示例
##### 猜数字,设定一个理想数字比如:66,让用户输入数字,如果比66大,则显示猜测的结果大了;如果比66小,则显示猜测的结果小了;只有等于66,显示猜测结果正确,然后退出循环。
while True:
number = input('请输入一个数字:')
number = int(number)
if number > 66:
print('数字大了')
elif number == 66:
print('答对了')
break
else:
print('小了')
2.9.3 continue关键字
作用:退出当前循环,继续下一次循环
- 示例
#### 使用两种方法实现输出 1 2 3 4 5 6 8 9 10 。
count = 0
while count <= 9:
count = count + 1
if count == 7:
continue
print(count)
2.9.4 while else
作用:如果while 后的条件不再满足引发循环再继续,则执行else中的内容。如果是因为 break 引发的循环不再执行,则不执行else中的内容。
- 示例
count = 0
while count <= 5:
print(count)
count += 1
else:
print('窗前明月光,疑是地上霜')
2.10 for循环语句
2.11 格式化输出
"%" 运算符就是用来格式化字符串的。在字符串内部,%s表示用字符串替换,%d表示用整数替换,有几个%占位符,后面就跟几个变量或者值,顺序要对应好。
占位符 | 替换内容 |
---|---|
%s | 字符串 |
%d | 整数 |
%% | 显示单独的% |
- 示例1
>>> 'Age: %s. Gender: %s' % (25, True)
'Age: 25. Gender: True'
>>>
- 示例2
name = input('请输入姓名:')
age = input('请输入年龄:')
job = input('请输入职业:')
hobby = input('请输入爱好:')
msg = '''
------------ info of Alex Li ----------
Name : %s
Age : %s
job : %s
Hobbie: %s
------------- end ----------------'''
print(msg%(name,age,job,hobby))
### 运行后 ###
请输入姓名:高启芝
请输入年龄:18
请输入职业:开发
请输入爱好:你懂的
------------ info of Alex Li ----------
Name : 高启芝
Age : 18
job : 开发
Hobbie: 你懂的
------------- end ----------------
- 示例3
num = input('>>>>')
s = '下载进度:%s%%'%(num)
print(s)
2.12.运算符
2.12.1算术运算符
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 - 两个对象相加 | a + b 输出结果 31 |
- | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 |
* | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 |
/ | 除 - x 除以 y | b / a 输出结果 2.1 |
% | 取模 - 返回除法的余数 | b % a 输出结果 1 |
** | 幂 - 返回x的y次幂 | a**b 为10的21次方 |
// | 取整除 - 向下取接近除数的整数 | 10//3 结果为3 |
2.12.2 比较运算符
运算符 | 描述 | 实例 |
---|---|---|
== | 等于 - 比较对象是否相等 | (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。 |
2.12.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 |
2.12.4 逻辑运算符
运算符 | 逻辑表达式 | 描述 | 实例 |
---|---|---|---|
and | x and y | 布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 | (a and b) 返回 20。 |
or | x or y | 布尔"或" - 如果 x 是 True,它返回 x 的值,否则它返回 y 的计算值。 | (a or b) 返回 10。 |
not | not x | 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 | not(a and b) 返回 False |
2.12.5.成员运算
判断子元素是否在原字符串(字典,列表,集合)中
- in(判断子元素存在)
示例1
>>> value = "我是中国人"
>>> v1 = "中国" in value
>>> print(v1)
True
示例2
while True:
content = input('请输入内容:')
if "退钱" in content:
print('包含敏感字符')
else:
print(content)
break
- not in(判断子元素不存在)
2.12.6 优先级
在没有()的情况下not 优先级高于 and,and优先级高于or,即优先级关系为( )>not>and>or,同一优先级从左往右计算。
第三章 数据类型
3.1 整型(int)
任意大小的整数,当然包括负整数
>>> 100
100
>>> -9999
-9999
>>>
3.1.1 整型的长度
python2:
- 在32位机器上,整数的位数为32位,取值范围为-231~231-1,即-2147483648~2147483647
- 在64位系统上,整数的位数为64位,取值范围为-263~263-1,即-9223372036854775808~9223372036854775807
- 超出长度之后就会变为long类型。
python3:
- 只有int没有long,所有数字都是int类型。
3.1.2 整除
在python2中使用除法时,只能保留整数位,如果想要保留小数位,可以先导入一个模块。
>>> from __future__ import division
>>> value = 3/2
>>> print(value)
1.5
>>>
>>> value = 10/3
>>> print(value)
3.33333333333
3.2 布尔(bool)
一个布尔值只有True,False两种值,要么是true要么是false
布尔值就是用于表示真假。True和False。
>>> True
True
>>> 3 > 2
True
>>> False
False
>>> 3 > 5
False
>>> 30 > 66
False
>>> 444 > 333
True
>>>
其他类型转换成布尔值:
- str
- ...
对于:None / "" / 0 .... -> false
3.3 字符串(str)
字符串是写代码中最常见的,python内存中的字符串是按照:unicode 编码存储。对于字符串是不可变。
3.3.1 字符串相加
字符串拼接,相加的规则就是必须都是字符串才能相加
>>> a = "hello"
>>> b = "word"
>>> print(a+b)
helloword
3.3.2 字符串相乘
字符串的乘法就是将多个字符串拼接到一起,乘法的规则:只能是字符串和数字相乘
>>> a = "hello"
>>> b = 5
>>> print(a*b)
hellohellohellohellohello
- 字符串中是不能进行减法和除法操作的
3.3.3 索引
索引就是对字符串中的每个元素从左到右进行有序的编码,从0开始,所以每个字符串中的第一个元素的索引就是0.
当索引是负数是,表示从右到左取元素,由于-0等于0,所以,-1就代表了从右到左的第一个元素
- 示例
>>> name = "ABCDE"
>>> print(name[0])
A
>>> print(name[1])
B
>>> print(name[2])
C
>>> print(name[-1])
E
>>> print(name[-2])
D
>>> print(name[-0])
A
3.3.4 切片
切片就是通过索引取出字符串的某一段,[第一个位置是开始:第二个位置是终止]中间必须使用分号。
默认终止的索引是不会包含在获取的内容中
- 示例
>>> name = "ABCDE"
>>> print(name[:1])
A
>>> print(name[1:])
BCDE
>>> print(name[1:4])
BCD
>>> print(name[1:-1])
BCD
>>> print(name[1:-2])
BC
3.3.5 步长
中括号里第一个参数是起始位置,第二参数是终止位置,第三个参数现在告诉大家是步长(每次走几步)
>>> name = "ABCDE"
>>>
>>> print(name[:1:2])
A
>>> print(name[::2])
ACE
>>> print(name[::-2]) # 负数就是倒着取
ECA
>>>
3.3.6 字符串方法详解
【补充】首字母大写、大小写翻转、每个隔开的(特殊字符和数字)单词首字母大写
s = 'alex Wusir' #首字母大写
s1 = s.capitalize() #首字母大写# print(s1) #Alex wusir
s3 = s.swapcase() #大小写翻转
print(s3) #ALEX wUSIR
a = 'zhangyang zy yy'
a1 = a.title() #每个隔开的(特殊字符和数字)单词首字母大写
print(a1) #Zhangyang Zy Yy
1.全部大写 upper()
- 示例
>>> name = 'abcdef'
>>> new_name = name.upper()
>>> print(new_name)
ABCDEF
#######
>>> name = 'ABCdef123'
>>> new_name = name.upper()
>>> print(new_name)
ABCDEF123
>>>
##################
v = 'ALEX'
v1 = v.upper()
print(v1)
v2 = v.isupper() # 判断是否全部是大写
print(v2)
2.全部小写 lower()
- 示例
>>> name = 'ABCDEF'
>>> new_name = name.lower()
>>> print(new_name)
abcdef
################
>>> name = 'ABCdef123'
>>> new_name = name.lower()
>>> print(new_name)
abcdef123
3.字符串替换 replace()
replace() 方法把字符串中的 old(旧字符串) 替换成 new(新字符串),如果指定第三个参数max,则替换不超过 max 次
- replace()方法语法:
str.replace(old, new[, max])
- 参数
old -- 将被替换的子字符串。
new -- 新字符串,用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
- 示例
message = input('请说话:')
print(message)
data = message.replace('大爷',"**",2)# 将大爷替换成**,替换不超过2次
print(data)
4.去除字符 strip()
- strip()的语法
str.strip([chars])
- 参数
chars 代表要去除的字符,默认是空格
strip() 是去除头尾。
- 示例
name = ' AB, CD, E, F, G '
new_name = name.strip()
print("--->",new_name,"<---")
---> AB, CD, E, F, G <---
lstrip() 是去除左边的字符
- 示例
name = ' AB, CD, E, F, G '
new_name = name.lstrip()
print("--->",new_name,"<---")
---> AB, CD, E, F, G <---
rstrip()是去除右边的字符
- 示例
name = ' AB, CD, E, F, G '
new_name = name.rstrip()
print("--->",new_name,"<---")
---> AB, CD, E, F, G <---
5.字符切割 split()
通过指定分隔符对字符串进行切片
- split() 语法:
str.split(分隔符, 分割次数)
split() 从左到右切割
rsplit() 从右到左切割
- 示例
>>> message = "小黑现在一脸懵逼,因为昨天晚上一直在学习,直到深夜。"
>>> result = message.rsplit(',',1)
>>> print(result)
['小黑现在一脸懵逼,因为昨天晚上一直在学习', '直到深夜。']
>>> result = message.rsplit(',')
>>> print(result)
['小黑现在一脸懵逼', '因为昨天晚上一直在学习', '直到深夜。']
6.判断是否是数字: isdecimal/.isdigit()
v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit() # '1'-> True; '二'-> False; '②' --> True
v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
print(v1,v2,v3)
# 以后推荐用 isdecimal 判断是否是 10进制的数。
# ############## 应用 ##############
v = ['alex','eric','tony']
for i in v:
print(i)
num = input('请输入序号:')
if num.isdecimal():
num = int(num)
print(v[num])
else:
print('你输入的不是数字')
7.是否以什么开头.startswith()
name = 'AB, CD, E, F,G '
new_name = name.startswith("A")
print("--->",new_name,"<---")
---> True <---
##############################
name = 'AB, CD, E, F,G '
new_name = name.startswith("a")
print("--->",new_name,"<---")
---> False <---
8. 是否以什么结尾.endswith()
name = 'AB, CD, E, F,G'
new_name = name.endswith("G")
print("--->",new_name,"<---")
---> True <---
##############################
name = 'AB, CD, E, F,G'
new_name = name.endswith("g")
print("--->",new_name,"<---")
---> False <---
9. 格式化输出.format()
name = 'AB, CD, E, F,G,{}'
new_name = name.format("呵呵呵")
print("--->",new_name,"<---")
---> AB, CD, E, F,G,呵呵呵 <---
10.连接字符串.join()
name = 'AB, CD, E, F,G'
new_name = "_".join(name)
print("--->",new_name,"<---")
---> A_B_,_ _C_D_,_ _E_,_ _F_,_G <---
11.统计次数.count()
name = 'AB, CD, E, F,G,ABC,AC'
new_name = name.count("A")
print("--->",new_name,"<---")
---> 3 <---
12.指定编码格式.encode()
name = 'ABCDEF'
new_name = name.encode("GBK")
print("--->",new_name,"<---")
---> b'ABCDEF' <---
#######################
name = 'ABCDEF'
new_name = name.encode("UTF-8")
print("--->",new_name,"<---")
---> b'ABCDEF' <---
######################
name = '努力'
new_name = name.encode("UTF-8")
print("--->",new_name,"<---")
---> b'\xe5\x8a\xaa\xe5\x8a\x9b' <---
######################
name = '努力'
new_name = name.encode("GBK")
print("--->",new_name,"<---")
---> b'\xc5\xac\xc1\xa6' <---
3.4 列表(list)
列表是python的基础数据类型之一 ,它是以[ ]括起来, 每个元素用’ , ‘隔开而且可以存放各种数据类型:
比如:
lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
3.4.1. 列表的索引
列表也拥有索引:
>>> lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
>>> print(lis[0])
alex
>>> print(lis[1])
WuSir
>>> print(lis[2])
ritian
>>> print(lis[3])
barry
3.4.2. 列表的切片
列表可以根据索引进行切片
lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
>>> print(lis[0:3])
['alex', 'WuSir', 'ritian']
>>> print(lis[0:-1])
['alex', 'WuSir', 'ritian', 'barry']
>>> print(lis[1::2])
['WuSir', 'barry']
>>>
3.4.3 列表的嵌套
>>> lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
>>> print(lis[3])
['qwe', 20, ['k1', ['tt', 3, '1']], 89]
>>> print(lis[3][2])
['k1', ['tt', 3, '1']]
>>> print(lis[3][2][0])
k1
>>> print(lis[3][2][1])
['tt', 3, '1']
3.4.4 列表方法详解
1.追加.append()
user_list = ["alex","wusir","ritian","jing"]
user_list.append("摸摸哒")
print(user_list)
['alex', 'wusir', 'ritian', 'jing', '摸摸哒']
2.插入.insert()
user_list = ["alex","wusir","ritian","jing"]
user_list.insert(0,"摸摸哒")
print(user_list)
['摸摸哒', 'alex', 'wusir', 'ritian', 'jing']
3.按索引删除.pop()
user_list = ["alex","wusir","ritian","jing"]
user_list.pop(3)
print(user_list)
['alex', 'wusir', 'ritian']
4.按内容删除.remove()
user_list = ["alex","wusir","ritian","jing"]
user_list.remove("alex")
print(user_list)
['wusir', 'ritian', 'jing']
5.清空列表.clear()
user_list = ["alex","wusir","ritian","jing"]
user_list.clear()
print(user_list)
[]
6.del(按索引删除,可以切片删除)
a = ['kngiht','kevin','qaz',1,2,3]
del a[2:4]
print(a) #['kngiht', 'kevin', 2, 3] 按索引切片删除
7.迭代添加.extend ()
user_list = ["alex","wusir","ritian","jing"]
user_list.extend(["摸摸哒","呵呵哒","佩琦"])
print(user_list)
['alex', 'wusir', 'ritian', 'jing', '摸摸哒', '呵呵哒', '佩琦']
8.反转列表内容.reverse()
user_list = ["alex","wusir","ritian","jing"]
user_list.reverse()
print(user_list)
['jing', 'ritian', 'wusir', 'alex']
9.排序.sort()
## 正向排序
user_list = [1,2,3,4,5,5,6,5,4,3,2,16,100,20]
user_list.sort()
print(user_list)
[1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 6, 16, 20, 100]
## 反向排序
user_list = [1,2,3,4,5,5,6,5,4,3,2,16,100,20]
user_list.sort(reverse=True)
print(user_list)
[100, 20, 16, 6, 5, 5, 5, 4, 4, 3, 3, 2, 2, 1]
3.5 元组(tuple)
不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.
>>> lis = ("alex", "WuSir", "ritian", "barry", "wenzhou")
>>>
>>> print(lis[0])
alex
>>> print(lis[1:4])
('WuSir', 'ritian', 'barry')
>>> print(lis[1:])
('WuSir', 'ritian', 'barry', 'wenzhou')
>>> print(lis[1:-1])
('WuSir', 'ritian', 'barry')
>>> print(lis[::-1])
('wenzhou', 'barry', 'ritian', 'WuSir', 'alex')
>>>
关于不可变, 注意: 这里元组的不可变的意思是子元素不可变. 而子元素内部的子元素是可以变, 这取决于子元素是否是可变对象.
元组中如果只有一个元素. 一定要添加一个逗号, 否则就不是元组
>>> tup = ("keep")
>>> print(type(tup)) # type是查看数据类型
<class 'str'>
>>> tup = ("keep",)
>>> print(type(tup))
<class 'tuple'>
元祖嵌套
>>> tu = ('今天姐姐不在家','姐夫和小姨子在客厅聊天',('姐夫问小姨子税后多少钱',' 小姨子低声说道说和姐夫还提钱'))
>>>
>>> print(tu1)
今天姐姐不在家
>>> print(tu2)
姐夫和小姨子在客厅聊天
>>> print(tu3)
姐夫问小姨子税后多少钱
>>> print(tu4)
小姨子低声说道说和姐夫还提钱
元组(不可变)
- 公共
- 索引
- 切片
- 步长
- for
- len
3.6 字典(dict)
字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成。
和列表list比较,字典dict有以下几个特点:
- 查找和插入的速度极快,不会随着key的增加而变慢;
- 需要占用大量的内存,内存浪费多。
而list相反:
- 查找和插入的时间随着元素的增加而增加;
- 占用空间小,浪费内存很少。
在dict中key是 唯⼀的.在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中,这种算法被称为hash算法。
可以改变的都是不可哈希的, 那么可哈希就意味着不可变. 这个是为了能准确的计算内存地址⽽规定的.
3.6.1 语法
{'key1':1,'key2':2}
注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据
数据类型划分:可变数据类型,不可变数据类型
不可变数据类型:元组,bool,int str -->可哈希
可变数据类型:list,dict,set --> 不可哈希
dict key(键) 必须是不可变数据类型(可哈希) value(值):任意数据类型
3.6.2 字典方法
1.增加
dic = {'age':18,'name':'jin','sex':'male',}
1.1
dic['hight']=180 # 没有键值对会新增
print(dic)#{'age': 18, 'name': 'jin', 'sex': 'male', 'hight': 180}
dic['age']=16 #如果有键,则值会覆盖
print(dic)#{'age': 16, 'name': 'jin', 'sex': 'male', 'hight': 180}
1.2
dic.setdefault('weight') #有键值对,不做任何改变,没有则添加
dic.setdefault('weight',150)
dic.setdefault('name','erge')
print(dic)#{'age': 16, 'name': 'jin', 'sex': 'male', 'hight': 180, 'weight': None}
2.删除
2.1 pop
print(dic.pop('age'))#16 返回age对应的值
print(dic.pop('二哥',None)) #None 为了防止删除的时候没有要删除的键,而报错设置一个返回值,也可以是字符串'没有此键'
print(dic.pop('name',None)) #jin 删除有的键,即使设置了返回值None也不会返回,而是返回删除成功的值 jin
print(dic) #{'name': 'jin', 'sex': 'male', 'hight': 180, 'weight': None}
2.2 popitem
print(dic.popitem()) #随机删除一个元素,并把删除元素的键和值放在一个元组里返回:(key, value)。
#返回值 ('weight', None)
print(dic) #{'sex': 'male', 'hight': 180}
2.3 del
del dic['sex'] #del +键,按键来删除
print(dic) #{'hight': 180}
del dic #删除字典
print(dic)
2.4 clear 清空字典
dic.clear(dic)
print(dic)
3.更改
3.1
dic['age']=16 #如果有键,则值会覆盖
3.2
dic = {'name':'zy','age':18,'sex':'male'}
dic2 = {'name':'alex','weight':'150'}
dic2.update(dic) #一样的键,值会覆盖,不一样的键,会新增
print(dic2) #{'name': 'zy', 'weight': '150', 'age': 18, 'sex': 'male'}
4.查询
dic1 = {'name':'zy','age':18,'sex':'male',}
4.1
print(dic1.keys()) #dict_keys(['name', 'age', 'sex'])
print(dic1.values()) #dict_values(['zy', 18, 'male'])
print(dic1.items()) #dict_items([('name', 'zy'), ('age', 18), ('sex', 'male')])
print(dic1['name']) #返回值 zy
print(dic1['name1']) #会报错,找不到这个键 KeyError: 'name1'
4.2
#这时可以用dic1.get() 设置一个返回值 如下:
print(dic1.get('name1','没有这个键')) #没有这个键
用循环查询
for i in dic1: #dic1与dicdic1.keys()一样,只打印出键
print(i) #name age sex
for i in dic1.keys(): #name age sex
print(i)
for i in dic1.values():
print(i) #zy 18 male
for i in dic1.items(): #返回的是元组,元组里是键值对
print(i) #('name', 'zy') ('age', 18) ('sex', 'male')
计算长度.len()
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
items_dic = dic.update({"悟空":"金箍棒"})
print(len(dic))
4
3.6.3 字典的嵌套
>>> dic = {
... 'name':'汪峰',
... 'age':48,
... 'wife':[{'name':'国际章','age':38}],
... 'children':['第一个熊孩子','第二个熊孩子']
... }
>>>
>>>
>>> d1 = dic['wife'][0]['name']
>>> print(d1)
国际章
>>> d2 = dic['children']
>>> print(d2)
['第一个熊孩子', '第二个熊孩子']
>>> d3 = dic['children'][0]
>>> print(d3)
第一个熊孩子
3.7 集合(set)
set集合是python的⼀个基本数据类型. ⼀般不是很常⽤. set中的元素是不重复的.⽆序的.⾥ ⾯的元素必须是可hash的(不可变数据类型)
3.7.1集合的方法
1.添加.add()
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s1.add("蔡徐坤")
print(s1)
{'刘能', '蔡徐坤', '⽪⻓⼭', '赵四'}
2. 删除.discard()
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s1.discard("赵四")
print(s1)
{'刘能', '⽪⻓⼭'}
3.交集.intersection()
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.intersection(s2)
print(s)
{'⽪⻓⼭'}
4.并集.union()
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.union(s2)
print(s)
{'赵四', '冯乡⻓', '刘能', '⽪⻓⼭', '刘科⻓'}
5.差集.difference()
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.difference(s2)
print(s)
{'赵四', '刘能'}
##################
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s2.difference(s1)
print(s)
{'冯乡⻓', '刘科⻓'}
6.反交集.symmetric_difference()
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s2.symmetric_difference(s1)
print(s)
{'赵四', '刘能', '冯乡⻓', '刘科⻓'}
7.计算长度.len()
s1 = {"刘能", "赵四", "⽪⻓⼭"}
print(len(s1)) #3
3.7.2 嵌套问题
# 1. 列表/字典/集合 -> 不能放在集合中+不能作为字典的key(unhashable) # info = {1, 2, 3, 4, True, "国风", None, (1, 2, 3)} # print(info) # 2. hash -> 哈希是怎么回事? # 因为在内部会将值进行哈希算法并得到一个数值(对应内存地址),以后用于快速查找。 # 3. 特殊情况 # info = {0, 2, 3, 4, False, "国风", None, (1, 2, 3)} # print(info) # info = { # 1:'alex', # True:'oldboy' # } # print(info)
3.8 公共功能
- len
- 索引
- 切片
- 步长
- for循环
3.9 内存相关
3.9.1 id,查看内存地址
>>> v1 = [11,22,33]
>>> v2 = [11,22,33]
>>> print(id(v1),id(v2)) # 比较两个变量的内存值
4472652360 4473773640
# 对于 -5 ~ 256 的整数来说会有小地址池的概念,不会创建新的内存地址
>>> v1 = "我,你,他,它,她"
>>> v2 = "我,你,他,它,她"
>>> print(id(v1),id(v2))
4473666128 4473665840
# 赋值,就是把v2指向了v1的内存地址,所以他们的内存地址一样
>>> v1 = "我,你,他,它,她"
>>> v2 = v1
>>> print(id(v1),id(v2))
4473666128 4473666128
# 重新赋值,v1的内存地址变了,但是v2的内存地址没变
>>> v1 = "我,你,他,它,她"
>>> v2 = v1
>>> v1 = "我,你,他,它,她,天"
>>> print(id(v1),id(v2))
4473665840 4473666128
>>> print(v2)
我,你,他,它,她
is,比较内存地址
>>> v1 = {'k1':'v1','k2':[1,2,3]}
>>> v2 = {'k1':'v1','k2':[1,2,3]}
>>> result1 = v1 == v2
>>> result2 = v1 is v2
>>> print(result1)
True
>>> print(result2)
False
is 和 == 的区别?
== 用于比较值是否相等。
is 用于比较内存地址是否相等。
3.10 类型转换
1.数字转字符串
>>> v1 = 666
>>> v2 = str(v1)
>>> print (v2)
666
2.数字转布尔
>>> v1 = 0
>>> v2 = bool(v1)
>>> print (v2)
False
#######################
>>> v1 = 666
>>> v2 = bool(v1)
>>> print (v2)
True
非零值转布尔都是True,0转布尔是False
3.字符串转数字
>>> v1 = "666"
>>> v2 = int(v1)
>>> print (v2)
666
### 字符串内容是数字时,可以转换成数字
>>> v1 = "hello2"
>>> v2 = int(v1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'hello2'
###字符串含有数字以外的字符时,不能转换成数字
>>> v1 = ""
>>> v2 = int(v1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ''
###空字符串不能转换成数字
4.字符串转布尔值
>>> v1 = "66q3"
>>> v2 = bool(v1)
>>> print(v2)
True
### 非空字符串转换布尔值都是True
>>> v1 = ""
>>> v2 = bool(v1)
>>> print(v2)
False
### 空字符串转换布尔值是Fales
5.布尔值转换数字
>>> v1 = True
>>> v2 = int(v1)
>>> print(v2)
1
>>> v1 = False
>>> v2 = int(v1)
>>> print(v2)
0
6.布尔值转换字符串
>>> v1 = True
>>> v2 = str(v1)
>>> print(v2)
True
>>> v1 = False
>>> v2 = str(v1)
>>> print(v2)
False
第四章 文件操作
4.1 文件基本操作
obj = open('路径',mode='模式',encoding='编码')
obj.write()
obj.read()
obj.close()
4.2 打开模式
- r / w / a
- r+ / w+ / a+
- rb / wb / ab
- r+b / w+b / a+b
4.3 操作
read() , 全部读到内存
read(1)
1表示一个字符
obj = open('a.txt',mode='r',encoding='utf-8') data = obj.read(1) # 1个字符 obj.close() print(data)
1表示一个字节
obj = open('a.txt',mode='rb') data = obj.read(3) # 1个字节 obj.close()
write(字符串)
obj = open('a.txt',mode='w',encoding='utf-8') obj.write('中午你') obj.close()
write(二进制)
obj = open('a.txt',mode='wb') # obj.write('中午你'.encode('utf-8')) v = '中午你'.encode('utf-8') obj.write(v) obj.close()
seek(光标字节位置),无论模式是否带b,都是按照字节进行处理。
obj = open('a.txt',mode='r',encoding='utf-8') obj.seek(3) # 跳转到指定字节位置 data = obj.read() obj.close() print(data) obj = open('a.txt',mode='rb') obj.seek(3) # 跳转到指定字节位置 data = obj.read() obj.close() print(data)
tell(), 获取光标当前所在的字节位置
obj = open('a.txt',mode='rb') # obj.seek(3) # 跳转到指定字节位置 obj.read() data = obj.tell() print(data) obj.close()
flush,强制将内存中的数据写入到硬盘
v = open('a.txt',mode='a',encoding='utf-8') while True: val = input('请输入:') v.write(val) v.flush() v.close()
4.4 关闭文件
文艺青年
v = open('a.txt',mode='a',encoding='utf-8')
v.close()
二逼
with open('a.txt',mode='a',encoding='utf-8') as v:
data = v.read()
# 缩进中的代码执行完毕后,自动关闭文件
4.5 文件内容的修改
with open('a.txt',mode='r',encoding='utf-8') as f1:
data = f1.read()
new_data = data.replace('飞洒','666')
with open('a.txt',mode='w',encoding='utf-8') as f1:
data = f1.write(new_data)
大文件修改
f1 = open('a.txt',mode='r',encoding='utf-8')
f2 = open('b.txt',mode='w',encoding='utf-8')
for line in f1:
new_line = line.replace('阿斯','死啊')
f2.write(new_line)
f1.close()
f2.close()
with open('a.txt',mode='r',encoding='utf-8') as f1, open('c.txt',mode='w',encoding='utf-8') as f2:
for line in f1:
new_line = line.replace('阿斯', '死啊')
f2.write(new_line)