【从0学测开】—常用Python技能

📢博客主页：卷测开的快乐人 📢欢迎点赞 👍 收藏 ⭐留言 📝 欢迎讨论！
📢本文由 【卷测开的快乐人】 原创，
首发于 CSDN🙉🙉🙉 📢
由于博主是在学小白一枚，难免会有错误，有任何问题欢迎评论区留言指出，感激不 尽！✨ 📖精品专栏（不定时更新）

测开为啥学Python

学习的前提，我们首先肯定要考虑我们的学习成本吧，相对来说，python接近自然语言，上手速度快。有很多说三天入门python，相对于java来说python是更容易上手的。针对选择语言入门来说呢，python更适合打开语言的大门。所以相对来说，python更加容易上手，我们可以把python作为入行语言的首选。如果有了其他编程语言为基础的也可以使用python来作为下一门语言。（如果找工作面试官看见，哇Java和Python都会岂不是希望更大）

Python的基础语法

Python和Java最大的不同在于，Python的缩进，非常严格。

Python中使用缩进表示语句块.
同一个语句块中的代码必须保证严格的左对齐(左边有同样数目的空格和制表符).

例如：下面有一个这样的图片，JAVA代码这样写说不定可以通过，可是Python就不行了。

这里缩进不一样，因此代码跑不过去。

Python的赋值

这是Python特别的地方

多重赋值

可以同时给多个变量赋相同的值

x=y=1

多元赋值

可以同时给多个变量赋不同的值

x, y = 1, 2

怎么证明Python牛逼

我们不是学了C语言里, 如何交换两个变量嘛?
c的写法

int a = 10;
int b = 20;
int tmp = a;
a = b;
b = tmp;

Python写法（我心里就俩字牛逼）

x, y = 10, 20
x, y = y, x

向这样的例子还有很多。

增量赋值

Python在这里没有++，–的，其实最开始我学习的时候，就感觉++，–不好用，没想到Python就直接没有，太顶了。
Python是通过这些方法进行赋值的。

字符串 只适用于字符串的 *** 作符

x = 1 
print("x = %d" % x) 
 
# 执行结果 
x = 1 

支持以下这些格式化字符串

Python常见的字符串函数

1. join
把列表合并为一个字符串

a = ['aa', 'bb', 'cc', 'dd'] 
print(' '.join(a)) 
 
# 执行结果 
'aa bb cc dd'

2. split
按空格将字符串分割成列表

a = 'aa bb cc dd' 
print(a.split(' ')) 
 
# 执行结果 
['aa', 'bb', 'cc', 'dd']

3. startswith和endwith
判定字符串开头结尾

a = 'hello world' 
print(a.startswith('hello')) 
print(a.endwith('world')) 
 
# 执行结果 
True 
True

4.strip
去除字符串开头结尾的空格/制表符

a = ' hello world ' 
print(a.strip()) 
 
# 执行结果 
hello world

5.find
查找子串
（这里会返回查找到的下标）

a = 'hello world' 
print(a.find('world')) 
 
# 执行结果 
6 

6.lower和upper
转换大小写

a = 'Hello World' 
print(a.lower()) 
print(a.upper()) 
 
# 执行结果 
hello world 
HELLO WORLD

列表和字典

列表

字符串只能由字符组成, 而且不可变; 但是列表中可以包含任意类型的对象, 使用更加灵活.

使用切片 *** 作符访问列表元素

列表的切片 *** 作和字符串完全一致.
但是列表还可以使用切片 *** 作修改元素.

列表常用 *** 作

1.修改 *** 作

a = [1, 2, 3, 4] 
a[0] = 100 
print(a) 
 
# 执行结果 
[100, 2, 3, 4] 

2.append：追加元素

a = [1, 2] 
a.append(3) 
print(a) 
 
# 执行结果 
[1, 2, 3] 

3.del
删除指定下标元素

a = [0, 1, 2] 
del (a[0]) 
print(a) 
 
# 执行结果 
[1, 2]

4.remove
按值删除元素

a = [1, 2, 3] 
a.remove(1) 
print(a) 
 
# 执行结果 
[2, 3] 

5.extend
列表相连

a = [1, 2] 
a.extend([3, 4]) 
print(a)  
# 执行结果 
[1, 2, 3, 4]

数据结构中的堆栈, 这是一种后进先出的数据结构. 可以很容易使用列表进行模拟

列表实现堆栈

a = [] 
a.append(1) # push *** 作 
print(a[-1]) # top *** 作, 取栈顶元素 
a.pop() # pop *** 作, 删除末尾元素 

列表实现队列

a = [] 
a.append(1) # push  *** 作 
print(a[0]) # 取队首元素 
a.pop(0) # pop *** 作, 出队列

元组

元组的很多 *** 作都和列表一样。唯一区别是元组只读

元组的常用 *** 作
切片 *** 作: 和列表相同
比较运算符, 规则和列表相同.
连接 *** 作(+), 重复 *** 作(*), 判定元素存在(in/not in)都和列表相同.
由于元组不可变, 所以并不支持append, extend, sort等修改自身的 *** 作.

x, y = y, x 在这个 *** 作我们就用了元组，其实, x, y 就是一个元组. 通过 y, x 这个元组创建了一个新的元组.

>>> x, y = 1, 2 
>>> x, y 
(1, 2)

理解元组的 “不可变”

元组的 “不可变” 指的是元组的每个元素的id不可变. 就是说一个元组包含了几个对象, 然后不可以给这个元
组再添加或者删除其中的某个对象, 也不可以将某个对象改成其他的对象.
如果元组中的某个元素, 是可变对象(比如列表或字典), 那么仍然是可以修改的.

a = ([1, 2, 3], [4, 5, 6]) 
a[0][0] = 100 # 这个东西是不是看起来长的很像C语言的 "二维数组" ? 
print(a) 
 
# 执行结果 
([100, 2, 3], [4, 5, 6])

“不可变” 真的有必要嘛? 假如我们只是用列表, 能否应付所有的应用场景呢?
答案是否定的. 既然Python的设计者提供了元组这个对象, 那么一定有一些情况下, 只有元组能胜任, 但是列表无法胜
任.
例如:

你有一个列表, 现在需要调用一个API进行一些处理. 但是你有不是特别确认这个API是否会把你的列表数据
弄乱. 那么这时候传一个元组就安全很多.
我们马上要讲的字典, 是一个键值对结构. 要求字典的键必须是 “可hash对象” (字典本质上也是一个hash
表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行.

字典

Python的字典是一种映射类型数据. 里面的数据是 键值对 . Python的字典是基于hash表实现的

键(key): 字典的键是唯一的(一个字典对象中不能有两个相同的键). 同时字典的键必须是可hash的(能够计算出一个固定的hash值)
值(value): 字典的值没啥限制. 数字, 字符串, 以及其他容器, 都可以作为字典的值.

创建字典

使用 { } 的方法, 我们前面已经介绍过了
使用工厂方法 dict

a = dict((['x', 1], ['y', 2])) 
print a 
 
# 执行结果 
{'x':0, 'y':0} 

使用字典的内建方法 fromkeys

a = {}.fromkeys(('x', 'y'), 0) 
print a 
 
# 执行结果 
{'x':0, 'y':0}

字典的键和值的类型, 不需要相同

修改字典元素

使用 [] 可以新增/修改字典元素. 如果key不存在, 就会新增; 如果已经存在, 就会修改.

a = {} 
a[1] = 100 
print(a) 
a[1] = 200 
print(a) 
 
# 执行结果 
{1:100} 
{1:200}

删除字典元素

使用del来删除某一个键值对

a = {1:100} 
del a[1] 
print(a) 
 
# 执行结果 
{}

使用clear方法, 清空整个字典中所有的键值对

a = {1:100, 2:200} 
a.clear() 
print(a) 
 
# 执行结果 
{} 

使用pop函数, 删除键值对, 同时获取到值

a = {1:100, 2:200} 

常用内置函数

len: 字典中键值对的数目
hash: 判定一个对象是否可hash. 如果可hash, 则返回hash之后的hashcode. 否则会运行出错.

print(hash(())) 
print(hash([])) 
 
# 执行结果 
3527539 
Traceback (most recent call last): 
 File "test.py", line 4, in <module> 
 print(hash([])) 
TypeError: unhashable type: 'list' 

keys: 返回一个列表, 包含字典的所有的key
values: 返回一个列表, 包含字典的所有value
items: 返回一个列表, 每一个元素都是一个元组, 包含了key和value

a = {'x':0, 'y':1} 
print(a.items()) 
 
# 执行结果 
[('y', 1), ('x', 0)] 

文件读写 文件的基础 *** 作

打开文件/关闭文件

f = open(‘test.txt’, ‘r’) # 打开文件
f.close() # 关闭文件

读文件
read: 读指定长度字节数的数据, 返回一个字符串.
readline: 读取一行数据, 返回一个字符串,
readlines: 读取整个文件, 返回一个列表. 列表中的每一项是一个字符串, 代表了一行的内容.
直接使用 for line in f 的方式循环遍历每一行. 功能和readline类似. 一次只读一行, 相比于readlines占用内存少, 但是访问IO设备的次数会增多, 速度较慢.

f = open(‘test.txt’, ‘r’)
print(f.readlines())

写文件
write: 向文件中写一段字符串.
如需写文件, 必须要按照 ‘w’ 或者 ‘a’ 的方式打开文件. 否则会写失败
writelines: 参数是一个列表, 列表中的每一个元素是一个字符串.
并没有一个 writeline 这样的函数. 因为这个动作等价于 write 时在字符串后面加上 ‘\n’. 同理, 使用
writelines的时候, 也需要保证每一个元素的末尾, 都带有 ‘\n’

f = open(‘test.txt’, ‘r’)
f.write(‘aaaaaaaaaaaaa’)
#执行结果
Traceback (most recent call last):
File “test.py”, line 4, in < module>
f.write(‘aaaaaaaaaaaaa’)
IOError: File not open for writing

代码错误原因就是没有打开文件，用完文件记得要及时关闭。