python基本语法整理

python刚刚开始入门，总结一下上网课 (小甲鱼) 时学到的python基本语法。
有一点c的基础，主要总结和c不太一样的地方。
持续更新

文章里面可能有很多英文，主要是因为一长串中/英文读起来容易找不到重点，将关键字用英语标出来, 对我个人读起来有些帮助

笔记

• 不需要semicolon ;
• indentation缩进代替{ }
• 变量不需要declare type，可以直接赋值。

print

• 不需要格式符号%d，%lf
• “” 或者’ '都可以用来标注字符串
• 每次print执行完了之后，都会默认换行。可以更改这一设定：

print("hello world", end='')
#end=规定每次打印结束以什么来结尾

• 一个print函数打印多个字符串

print(a, b, c)
#默认字符串用空格隔开

print("hello" * 3)
#打印“”里面的内容3次

--------------------
hellohellohello

print("hello" + "world")

----------------
helloworld

打印特殊符号

转义符号

当要打印字符串里面的 ’ 或者" 时，\n, \t, 或者位于句末的\时

print("lower\\")

---------------------
lower\

加上r

（只适用于\n, \t等，并且不包括位于句末的\）

string = r'\n\t'
print(string)

---------------------
\n\t

打印多行的字符串

使用三个“ 或者 ‘

print('''hello
world''')
#打印结果会自动换行

---------------------
hello
world

if else

不要忘记冒号和indentation

if a == 1:
	print(' a == 1')
elif a == 2:
	print(' a == 2')
else:
	pass

三元操作

string = a if a < b else b

if a < b:
	string = a
else:
	string = b

while

不支持do while

a = 1
while a < 2:
	print(a)
	a += 1
	#⚠️python不支持++,--

for

主要适用于list或者tuple
⚠️这里的i和j不是一个counter，而是这个list里面的一个元素element

for i in list1:
    for j in i:
        print(j)

运算符

逻辑运算符

&& and
|| or
! not

算数运算符

/ 为数学意义上的除法，整数之间相除可以得到小数
// 为floor除法，即使operands是小数，结果依然为小数（floor为整数）
** 幂

• 比左侧的单目运算符高，比右侧的低

-3 ** 2 == -9

3 ** -2 == 0.11111

比较符

支持 3<4<5，相当于 3<4 and 4<5

数据类型

区分int & float

有无小数点

科学记数法

默认为float

a = 1e-12

序列sequence

commonalities

• slice
• 重复操作（*），拼接（+），关系（in not in）
• 其他操作：

1. 判断序列里，是否含有另外一个序列
2. 查找某一个element或者sequence，返回其index
3. 查找index中存储的element
4. 查找最大/小值 （前提：所有elements为同一个类型）
5. 查找某个element出现的次数

• index支持负数，意为倒数 (e.g. -1意思是倒数第一)

列表list

• 空列表：[]
• 可以更改element，添加，删除

list1 = [1, 'hello', 2.0]
#可以存放不同类型的元素

下面的操作都会返回一个list，不会对原来的list作出改变
添加element

append(element)

list1.append(3)
#追加一个element，一次只能添加一个

extend(list)

list1.extend([0, 2.4])
#输入的list会与当前的list合成一个list

#或者
list2 = list1 + list2

insert(index, element)

list1.insert(0, 'hello')
#将一个element放到指定的index

删除element
remove(element)

list1.remove(0)
#删除输入的element

del list1[2]
del list1
#删除某一个element或者整个list

pop (index)

list1.pop(3)
#删除在这个index的element，并返回这个element
#默认为最后一个element

切片slice
[start : stop : step]

list1[1:3]
#截取从index1到3（不包含3）的elements
#第一个参数默认为0，第二个为最后的index, 第三个为1

list2 = list1[:]
#copy整个list, 更改list1并不会影响list2, vice versa

list2 = list1[1:9:2]
#step为2

比较大小

list1 == list2
#只有当所有element相同时为true

list1 < list2
#比较第一个不相同的element

检查是否存有一个element

if 'hello' in list2:
	print('yes')
if 'hello' not in lsit2:
	print('no')

某个element出现次数
count ( element )

list2.count('hello')

某个element第一次出现index
index ( element, start index, stop index )

list2.index('hello', 3, 7)
#返回这个element在[3, 7)内第一次出现的index
#如果没有出现，会出现valueError

倒序

list1.reverse()

排序

list1.sort()
#默认从小到大排序，不同参数排序不同

元组tuple

和list非常相近，但是不能改变

• 空元组 ()
• ⚠️创建元组的标志为逗号，而不是（）

tuple1 = (2, 3, 4)
tuple2 = (2,)
tuple3 = tuple1 * 3
tuple4 = tuple1[:2] + ('hello',) + tuple3[:]

字符串

• python没有字符，只有字符串
• 不可以通过index修改element，可以使用slice修改

str1 = 'hello!world'
str1 = str1[:5] + ' ' + str1[6:]

字符串操作

下面主要总结可以做什么，不介绍函数
⚠️涉及查找的函数，可以支持从左或从右查找

• 改变大小写
• 居中，左对齐，右对齐 字符串
• 判断字符串是否以sub string结束/开始
• 判断字符串里有无数字，字母，大小写，title（首字母大写）
• 用字符串分隔所有字符
• 去掉/替换 字符串中指定的sub string

格式化字符串：将某一个element按照规定的格式输出

format
用{}来表示需要replacement的地方

1. 未知参数 non-keyword

statement = "{0} has {1} files"
statement = statement.format("John", 10)
#⚠️format只是返回一个更新之后的字符串，并不是彻底更改statement

-------------------------
John has 10 files

2. 关键字参数 keyword

statement = "{a} has {b} files"
statement = statement.format(a = "John", b = 10)

----------------------------
John has 10 files

可以混合使用未知&关键字，但是未知必须在关键字之前使用

如果想要打印 { }

a = '{{0.1}} is a {0}'.format('union')
print(a)
#{}用来转义{}，相当于上面的转义符号，所以{1}会被当作普通character打印

---------------------
{0.1} is a union

格式化符号
%c

a = '%c %c %c' % (97, 99, 100) #⚠️一定要加括号
print(a)

-------------------
a c d

%s, %d

str1 = '%s += %d' % ('hello world!', 100)
print(str1)

------------------
hello world! += 100

%f, %e (%E), %g(%G)

%g 自动判断是使用小数还是科学记数法, 不支持指定精确到小数点后几位

#10.1， 10表示输出的结果至少为10位，如果不够空格来凑，1表示小数点后1位
str1 = '%0.1f == %10.1e == %g' % (1000000, 1000000, 1000000)
print(str1)

-----------------------
1000000.0 ==    1.0e+06 == 1e+06

其他： 左右对齐，正数前面加+， 不同进制，规定输出width（可选用空格还是0来填充）,百分比

字典dict

其实并不是一个数据类型，而是一个工厂函数。但是这里因为和sequence有相似之处，所以放在一起

• 映射mapping
• 通过输入key，来获取，或者重新赋值，相对应的某个value。类似于index和element在sequence中的关系
• 可以使用in 和not in，但是⚠️查找的是key，不是value。
• items没有指定的顺序

dict1 = {'apple' : '', 'banana' : '', a : b, 1 : 2}
#或者
dict1 = dict( ( ('apple', ''), ('banana', ''), (a, b), (1 , 2) ) )

 
print(dict1['apple'])
print(dict1[a])
print(dict1[1])

------------------

b
2

dict1['apple'] = 苹果 #重新赋值
#如果apple这个key不存在，python会自动创建一个item

字典操作

下面列举的并不是BIF，所以使用的时候需要明确是对哪一个dict操作：

e.g. dict1.fromkeys()

• fromkeys()，创建一个新的dict。可以用在如果在这个字典里所有keys都对应同样的value时。
• keys(), 返回dict里面的所有keys。一般用在for里面。类似的还有values(), items()
• get()，可以自定义，当access一个不存在的key时，返回的值。
• clear()，清空一个字典。彻底清除这一个指针(e.g. dict1)所指向的数据。
• pop(key)，返回，输入的key所对应的value，并且删除整个item
• popitem(), 随机删除并返回一个item
• setdefault(key, value) 在这个字典里添加一个item
• update(dict)，用一个字典来更新另外一个。（只更新两个字典中都有的key，所对应的value）

集合set

• 无序
• 不支持index索引 e.g.不可以写 set1[2]
• 支持in, not in
• 可以删除/添加element

set1 = {1, 3, 4, 2, 5, 4} #没有映射，使用花括号
#或者
set1 = set([1, 3, 4, 2, 5, 4])
#set()可以接收list, tuple, string


print(set1)

------------
{1, 2, 3, 4, 5}

⚠️集合里面所有的elements都是唯一的

frozenset 不可变集合
frozenset(), 一个工厂函数，用法与set()相似，但是创建一个不可以被更改的set

BIF

assert

assert condition

当condition结果为true时，程序正常运行。如果false，程序自动退出，显示assertion error
可以当作"break point“使用

assert a = 0
#assert 

input
返回用户输入的字符串 = input (输出的字符串)

a = int(input("Please enter a number"))

range
返回一个整数list = range (start, stop, step)
⚠️不包括stop

默认第一个参数为0，第三个为1

list2 = list(range(0, 10, 3))

-----------------
[0, 3, 6, 9]

list
将参数变成一个list
没有参数是，创建一个empty list

list2 = list(string1)
list1 = list()

类似的函数还有str, tuple

len
返回一个序列的长度（elements的数量）

max , min
返回一个序列中的最大/小值
⚠️elements必须为同一个type

sum
⚠️elements必须为同一个type
所有elements的总和

enumerate
可以将列表里的elements和其index组成一个个元组，最后组成列表

zip
将几个list合成一个list

filter
filter (function, sequence)

返回一个sequence中的所有， 可以让某一个函数返回True的elements。

如果不输入函数，返回所有为True的elements

返回的结果不是一个sequence，需要自己format一下

list1 = list(filter(lambda x: x % 2, range(0, 10)))

--------------
[1, 3, 5, 7, 9]

map
map (function, sequence)
返回所有elements传入某个函数后所得的结果

返回的结果不是一个sequence，需要自己format

list1 = list(map(lambda x: x + 1, range(-2, 3)))

-----------------
[-1, 0, 1, 2, 3]

函数

def isEven (number):
	if number % 2 == 0:
		return True
	else:
		return False

局部，全局变量

⚠️ python里，如果尝试在一个function里面对一个global variable重新赋值，需要明确某一个变量是global variable

def change():
	global globalV #这一句一定要有，否则结果为200
	globalV = 20

globalV = 200
change()
print(globalV)

-------------
20

如果没有写global：

def change():
	globalV = 20 #这里python重新创建了一个local variable，并且给它赋值20

globalV = 200
change()
print(globalV)

-------------
200

函数文档
和注释一样，在调用函数的时候不会被执行，但是可以帮助理解这个函数

def sum(num1, num2):
	'这是一个用来计算sum的函数‘ # 函数文档
	return num1 + num2

print(sum.__doc__)
#执行这个命令的时候，就会打印'这是一个用来计算sum的函数‘

参数

关键字参数&默认参数

在没有输入参数时，使用默认参数

def sum(num1 = 3, num2 = 6): #默认参数
	return num1 + num2

print(sum(num2 = 1, num1 = 2)) #关键字参数
print(sum())

收集参数
当不确定有多少个参数时

格式： def function(*参数名):

def sum(*params):
	result = 0
	for i in params:
		result += i
	print(result)

sum(1,2,55,43)

⚠️如果在收集参数之后，还想要添加别的参数。在调用的时候，要通过关键字参数的方法调用

print本身就有一个收集参数

内嵌函数 embedded function

内部函数可以调用外部函数内的variables，但是不可以重新赋值，除非使用"nonlocal"

def power(x):
	def helper():
		nonlocal x
		x *= x
		return x
	return helper() #这里是先调用helper，然后将helper返回的值返回；
	#如果写return helper, 返回的将是一个function

def multiply(num1):
	def helper(num2):
		return num1 * num2
	return helper 
	#这里return一个函数，因为multiply里面并没有num2，所以无法调用helper，并返回helper的返回值

multiply(2)(3)

lambda表达式

简化函数代码

def add(x, y):
	return x + y

返回函数 = lambda parameters : return的expression

add = lambda x, y: x+y

文件

打开一个文件

模式	操作
‘w’	写，如果文件已经存在，删除原有内容，重新写入；文件不存在，创建一个文件
‘r’	读
‘x’	如果文件存在，返回异常
‘a’	如果文件不存在，写入方式创建文件。如果文件存在，追加
‘t’	文本模式打开
‘b’	二进制打开
‘+’	读写（可以和其他模式一起使用）

open ('文件名‘ , ‘打开方式’)

 file1 = open('test', 'w')
 #打开/创建一个文件

文件操作
简单叙述以下可能的操作，具体如何去用请自己查询：

.close() 关闭文件
.read() 按照字符个数读取，返回文件内容。默认读取全部内容。
.readline() 按照行数读取
.tell() 返回文件指针的位置 in bytes！
.seek ()移动文件指针
.list() 可以直接将文件的内容变成一个list

⚠️，在for里面，甚至可以直接将文件当作一个sequence使用：

#假设有一个文本文件file1，已经被打开
for line in file1:
	print(line)

.write() 写入字符串
.write() 写入字符串sequence