Python 基础语法

**Python变量特性 **

1. Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建
2. 在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型
3. 变量的第一个字符必须是字母表中字母或下划线 _+

**Python 保留字 **

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，
可以输出当前版本的所有关键字

import keyword
print(keyword.kwlist)
print(keyword.iskeyword('is')

关键字

关键字是指Python中的保留字，是已经规定好的有其固定作用的词，定义变量时不能与关键字重名。关键字不是变量，只是一种有特殊用处的词语。keyword模块中的kwlist是一个列表，存放了Python中所有的关键字(str格式)。关键字其实很好分辨，就是编写代码时那些不曾定义过就直接使用的单词（不是符号），而且使用时决不能带括号，那就一定是关键字，用这个规则，再回忆编写一个模块的过程，就能把所有关键字想出来了。
上面的代码输出的结果是
[‘False’, ‘None’, ‘True’, ‘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’]
True
详细讲一下python库,
keyword模块提供了两个对象

# keyword.py 部分源码
__all__ = ["iskeyword", "kwlist"]

keyword.kwlist是一个列表，里面放着所有的关键字。
keyword.iskeyword()接收一个字符串参数，返回其是不是关键字(True/False)
iskeyword调用的是魔法方法__contains__

# keyword.py 部分源码
iskeyword = frozenset(kwlist).__contains__

**行与缩进 **

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} ，无需使用 ; 作为代码结尾
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数
if True:
print (“True”)
else:
print (“False”)

**print 变量打印 **

复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep – 用来间隔多个对象，默认值是一个空格。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。

a=1
c=2
print(a)
print(a,c)
print(a,end='')
print(a,c,sep='------')

输出结果
1
1 2
11------2

Python注释符

单行注释 #
多行注释 用三个单引号 ‘’’ 或者三个双引号 “”" 将注释括起来
‘’’
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
‘’’
多行注释 可以用来创建 长文本字符串

**基本数据类型 **

Python3 中有六个标准的数据类型

1. Number（数字）
2. String（字符串）
3. List（列表）
4. Tuple（元组）
5. Set（集合）
6. Dictionary（字典）

**变量赋值 **

a = 1 # 创建变量 a 赋值 为 1
a = b = 1 # 同时给多个变量赋值
a, b, c = 1, True, “hello” # 分别给a b c 赋值注意：布尔值标准写法 True False
这里想说一下python里面的单引号和双引号都是一样的效果

**打印变量类型 **

type() 接收一个数据，返回它的数据类型 ， print() 方法用于打印变量
print(type(a))# 打印 type 方法的输出

**删除变量 **

使用 del 关键字，将一个变量从内存中删除
del a # 删除 a 变量

**Number（数字） **

int、float、bool、complex（复数）
int 整数 eg: 1、 2、 3、 4
float 浮点数 eg: 1.1 , 100.00
bool 布尔值 True 、False # Python中 bool 属于 int 的子类， True 等于 1 、False 等
于 0
complex 复数 虚数部分用 j 表示, j前边要加数字 eg: 1+1j 、 1j * 1j 等于 -1 + 0j

String（字符串）

字符串用单引号 **’ **或双引号 **" **括起来，同时使用反斜杠 \ 转义特殊字符
字符串截取
str = ‘123456’
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次，也可以写成 print (2 * str)
print (“flag{”+str+“}”) # 连接字符串
转义字符 \
str = “123\n456”
print(str)
常用转义字符
\n 换行
\r 回车符
\t 制表符
\ 反斜杠 \
’ 单引号
" 双引号
\xyy 十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行

**List（列表） **

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至
可以包含列表
索引值以 0 为开始值，-1 为从末尾的开始位置

list = [ 'abc', 789 , 2.2, 'hello', 70.2 ] 
tinylist = [123, 'hello'] 
print (list)            # 输出完整列表 
print (list[0])         # 输出列表第一个元素 
print (list[1:3])       # 从第二个开始输出到第三个元素 
print (list[2:])        # 输出从第三个元素开始的所有元素 
print (tinylist * 2)    # 输出两次列表 
print (list + tinylist) # 连接列表 

列表值修改

a = [1, 2, 3, 4, 5, 6] 
a[0] = 9     
a[2:5] = [13, 14, 15] 
print(a) 
a[2:5] = []   # 将对应的元素值设置为 [] 
print(a) 
print(a[2])   # 下标不会删除

输出结果
[9, 2, 13, 14, 15, 6]
[9, 2, 6]
6

**Tuple（元组） **

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 **() **里，元素之间用逗号
隔开
tuple = ( ‘abc’, 789 , 2.2, ‘hello’, 70.2 )
tinytuple = (123, ‘hello’)
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组

tuple[0] = ‘ccc’ # 元组元素不能修改,会报错

而在Python中，只能将两个元组对象进行拼接
如果我将tinytuple=(‘sd’)换成这个
那么print(tuple+tinytuple)就会报错,因为tinytuple实际上是一个字符串而不是一个元组。请确保将它定义为一个包含单个元素的元组，可以通过在元素后面添加逗号来实现，例如tinytuple = (‘sd’,).

**Set（集合） **

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 **{ } **或者 **set() **函数创建集合，注意：创建一个空集合必须用 **set() **而不是 { }，因为 **{ } **
是用来创建一个空字典

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'} 
print(sites)   # 输出集合，重复的元素被自动去掉 
# 成员测试 
if 'Runoob' in sites : 
    print('Runoob 在集合中') 
else : 
    print('Runoob 不在集合中') 
# set可以进行集合运算 
a = set('abracadabra') 
b = set('alacazam') 
print(a) 
print(a - b)     # a 和 b 的差集 
print(a | b)     # a 和 b 的并集 
print(a & b)     # a 和 b 的交集 
print(a ^ b)     # a 和 b 中不同时存在的元素 

**Dictionary（字典） **

字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存
取的，而不是通过偏移存取。
字典是一种映射类型，字典用 **{ } **标识，它是一个无序的 **键(key) : 值(value) **的集合。
键(key)必须使用不可变类型
在同一个字典中，键(key)必须是唯一的。

dic = {'1': 'f', '2': 'l', '3': 'a', '4': 'g', '5': 'd'}
c = 21343242523154345
flag = 'flag{'

for i in str(c):  # 将数字转换为字符串，并迭代每一位数字
    flag += dic[i]
flag+='}'
print(flag)

这个代码大家应该可以看的懂吧
上面一个字典,下面是密文,一一遍历,最后打印出来.

数据类型转换

**函数 **
[int(x ,base])
float(x)
[complex(real ,imag])
str(x)
repr(x)
eval(str)
tuple(s)
list(s)
set(s)
dict(d)
frozenset(s)
chr(x)
ord(x)
hex(x)
oct(x)

---

将x转换为一个整数
将x转换到一个浮点数
创建一个复数
将对象 x 转换为字符串
将对象 x 转换为表达式字符串
用来计算在字符串中的有效Python表达式,并返回一个对象
将序列 s 转换为一个元组
将序列 s 转换为一个列表
转换为可变集合
创建一个字典。d 必须是一个 (key, value)元组序列。
转换为不可变集合
将一个整数转换为一个字符
将一个字符转换为它的整数值
将一个整数转换为一个十六进制字符串
将一个整数转换为一个八进制字符串

**Python运算符 **

**算术运算符 **
假设变量 a=10，变量 b=21：
**比较运算符 **
功能：对变量进行比较运算，返回结果均为TRUE或者FALSE
假设变量a=100，b=50的情况下，比较运算符如下：

运算符	功能	示例
==	相等	a==b,返回FALSE
!=	不等于	a!=b,返回TRUE
>	大于	a>b,返回TRUE
>=	大于等于	a>=b,返回TRUE
<	小于	a<b,返回FALSE
<=	小于等于	a<=b,返回FALSE

3、赋值运算符
功能：对变量进行赋值
假设a，b，c都为空变量，赋值运算如下

运算符	功能	示例
=	赋值	a=1，b=1+3，c=a+b
+=	加法赋值	a+=1等同于a=a+1
-=	加法赋值	a-=1等同于a=a-1
*=	乘法赋值	a*=1等同于a=a*1
/=	除法赋值	a/=1等同于a=a/1
**=	幂运算赋值	a**=1等同于a=a**1
\\=	整除赋值	a\\=1等同于a=a\\1
%=	取模赋值	a%=1等同于a=a%1
:=	海象赋值（表达式内为变量赋值）	(a:=a+1)>=1

4、位运算符
功能：对变量进行位运算
假设a，b，c都为空变量，运算符使用方法如下

运算符	功能	示例
&	二进制与运算	a&b
|	二进制或运算	a|b
^	二进制异或运算	a^b
~	二进制反运算	a~b
<<	二进制左移运算	a<<2
>>	二进制右移运算	a>>2

5、逻辑运算符
功能：对变量进行逻辑判断运算，返回结果为TRUE或者FALSE
如运算符两边为数值或字符串时，返回其中一个元素，具体规则请阅读专门的逻辑运算符文章：python运算符——逻辑运算符详解
逻辑运算符在运算时遵循的是短路逻辑，初学者建议同时阅读关于短路逻辑专门的文章：python逻辑运算符——短路逻辑 的具体解析

运算符	功能	实例
and	与运算	20>10 and 3>2,返回TRUE
or	或运算	20>10 and 1>2,返回TRUE
not	非运算	not(40>30),返回FALSE

运算符的优先级关系

python当中各类运算符的优先级如下表所示：优先级依次从高到低

运算符优先级排序	运算符内部优先次序
算数运算符	遵循四则运算规则
比较运算符(>,>=,<,<=)	>,>=,<,<=从左至右依次运算
比较运算符（==，!=）	==，!=从左至右依次运算
赋值运算符	从左至右依次运算
身份运算符	从左至右依次运算
成员运算符	从左至右依次运算
逻辑运算符（and）	and的优先级优于or和not
逻辑运算符（or，not）	从左至右依次运算

and 比 or 拥有更高优先级

x = True 
y = False 
z = False 
if x or y and z: 
    print("yes") 
else: 
    print("no") 

更多的字符串推荐https://www.runoob.com/python3/python3-string.html

**b \ r \ f 开头字符串 **

**字符串 与 bytes互转 **
bytes类型是指一堆字节的集合，在python中以b开头的字符串都是bytes类型

import base64

a=b'tweXRob255eWRzfQ=='
c=b'ZmxhZ3'
c += a
print(c)
print(base64.b64decode(c))

但是要注意变量c后面b开头的字符串是字节
如果, 没有b
a=‘tweXRob255eWRzfQ==’
c=b’ZmxhZ3’
c += a
这一步是报错a,c进行转换他俩必须要么都是字符串要么都是字节.
**原始字符串 **
r/R 开头的字符串，所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符

s=r'shh\nsd'
print(s)

**格式化字符串 **
format 是一种格式化字符串的函数， str.format()
format 函数可以接受不限个参数，位置可以不按顺序

a='zzm'
b='19'
print('my name is {},age is {}'.format(a,b))
print('my name is {1},age is {0}'.format(a,b))

my name is zzm,age is 19
my name is 19,age is zzm

**f-string **
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法
f-string 格式化字符串以 **f **开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量
或表达式计算后的值替换进去

name = 'tom' 
age = 18 
print(f'my name is {name}, age is {age} .') 

更多请见https://www.runoob.com/python3/python3-list.html

**列表方法 **

**添加元素 **

list.append()
在列表末尾添加新的对象

a=[1,2,3]
a.append(4)
print(a)

将指定对象插入列表的指定位置

a = [1,2,3] 
a.insert(0,5)  # 在开头插入一个对象 
print(a) 
arr.insert(len(a), 5) # 在结尾插入一个对象 
print(a) 

**列表长度 **

len(obj) 返回可遍历对象长度

import base64
a= 'e6Z9i~]8R~U~QHE{RnY{QXg~QnQ{^XVlRXlp^XI5Q6Q6SKY8jUAA'
b=''
for i in range(len(a)):
b+=chr(ord(a[i])-4)

print(base64.b64decode(b))

注释:ord(a[i]) 将返回字符 a[i] 的 ASCII 码值 ,chr() 函数将得到的 ASCII 码值转换回相应的字符.
后面会讲range()函数,可以选择直接跳转到那里看看

**删除元素 **
del()
删除某个变量

arr = [1,2,3] 
del arr[1] 
print(arr)

list.pop()
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

arr = [1,2,3] 
x = arr.pop() 
print(arr) 
print(x) 

list.clear()
清空列表

arr = [1,2,3] 
arr.clear() 
print(arr) 

**列表排序 **
list.sort( key=None, reverse=False)
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，
指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，**reverse = True **降序， **reverse = False **升序（默认）。

arr = [1,2,3,4] 
# 倒叙排列 
arr.sort(reverse=True) 
print(a) 

循环语句

if else 条件语句

if 判断条件：
执行语句……
else：
执行语句……
当判断条件为多个值时，可以使用以下形式
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……

**While 循环语句 **

while 判断条件(condition)：
执行语句(statements)……

**for 循环语句 **

for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串
for in :

else:

eg:
str=‘nimsdnsndns’
for i in str:
print(i)
遍历列表[‘’] 遍历字符串 遍历元组(‘’) 遍历集合 {‘’} 遍历字典dic{‘’:‘’}都是可以的
在这里三大循环语句我说的比较少,主要是他们重在运用.在其他函数或者其他地方写代码的时候就会带着一起写

range() 函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列

# 打印 0 ~ 4 range 表示要循环的次数 
for i in range(5): 
    print(i) 
# 遍历列表 
arr = ['a','b','c','d','e'] 
for i in range(5): 
    print(arr[i])

range() 可以指定区间 和步长

# 打印 1~10 之间的奇数 
# 步长为 2 
for i in range(1,10,2): 
    print(i)

# 创建一个 0~9 的列表
arr = list(range(10))
print(arr)

更好的例题,详情请见列表长度len()

**continue && break **

continue，break 用来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环

# continue 和 break 用法
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print(i)         # 输出双数2、4、6、8、10
i = 1
while 1:            # 循环条件为1必定成立
    print(i)        # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break
        
for letter in 'Runoob':     # 第一个实例
   if letter == 'o':        # 字母为 o 时跳过输出
      continue
   print ('当前字母 :', letter)
for letter in 'Runoob':     
   if letter == 'b':       # # 字母为 b 时退出
      break
   print ('当前字母为 :', letter)

**pass 语句 **
pass是空语句，是为了保持程序结构的完整性。
**pass **不做任何事情，一般用做占位语句
if 1 :
pass
else:
print(“pass 什么都不做”)

**定义一个函数 **

规则：
函数代码块以 **def **关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号 **: **起始，并且缩进。
**return [表达式] **结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回
None。
比较两个数，并返回较大的数:

def max(a, b):
    if a > b:
        return a
    else:
        return b 
a = 4 b = 5
print(max(a, b))

**参数传递 **

调用函数时可使用的正式参数类型：

1. 必需参数
2. 关键字参数
3. 默认参数
4. 不定长参数

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

def printme(str):
    print(str)
    return

printme('nmd')

**关键字参数 **

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参
数值。

def fun(name, age): 
    print(f"my name is {name}, age is {age} .") 
     
fun('tom', 18)     # 顺序传参 
fun(age=18, name='jack')    # 指定传参

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认
值

def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

**不定长参数 **

需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，声明时不会命名
加了星号 *** **的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

# 可写函数说明 
def printinfo( arg1, *vartuple ): 
   "打印任何传入的参数" 
   print ("输出: ") 
   print (arg1) 
   print (vartuple) 
# 调用printinfo 函数 
printinfo( 70, 60, 50 ) 

def fun(*d):
if(d):
a=0
for i in d:
a += i
print(a)

else:
print('请你输入大于0的个数')

fun(1,2,3,4)

**return语句 **

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回
None。

# 可写函数说明 
def sum( arg1, arg2 ): 
   # 返回2个参数的和." 
   total = arg1 + arg2 
   print ("函数内 : ", total) 
   return total 
# 调用sum函数 
total = sum( 10, 20 ) 
print ("函数外 : ", total) 

文件读取

open函数
open() 函数用于创建或打开指定文件，该函数的常用语法格式如下：

file = open(file_name [, mode=‘r’ [ , buffering=-1 [ , encoding = None ]]])
此格式中，用 [] 括起来的部分为可选参数，即可以使用也可以省略。其中，各个参数所代表的含义如下：

• file：表示要创建的文件对象。
• file_name：要创建或打开文件的文件名称，该名称要用引号（单引号或双引号都可以）括起来。需要注意的是，如果要打开的文件和当前执行的代码文件位于同一目录，则直接写文件名即可；否则，此参数需要指定打开文件所在的完整路径。
• mode：可选参数，用于指定文件的打开模式。可选的打开模式如表 1 所示。如果不写，则默认以只读（r）模式打开文件。
• buffering：可选参数，用于指定对文件做读写操作时，是否使用缓冲区（本节后续会详细介绍）。
• encoding：手动设定打开文件时所使用的编码格式，不同平台的 ecoding 参数值也不同，以 Windows 为例，其默认为 cp936（实际上就是 GBK 编码）。

open() 函数支持的文件打开模式如表

模式	意义	注意事项
r	只读模式打开文件，读文件内容的指针会放在文件的开头。	操作的文件必须存在。
rb	以二进制格式、采用只读模式打开文件，读文件内容的指针位于文件的开头，一般用于非文本文件，如图片文件、音频文件等。
r+	打开文件后，既可以从头读取文件内容，也可以从开头向文件中写入新的内容，写入的新内容会覆盖文件中等长度的原有内容。
rb+	以二进制格式、采用读写模式打开文件，读写文件的指针会放在文件的开头，通常针对非文本文件（如音频文件）。
w	以只写模式打开文件，若该文件存在，打开时会清空文件中原有的内容。

wb	以二进制格式、只写模式打开文件，一般用于非文本文件（如音频文件）
w+	打开文件后，会对原有内容进行清空，并对该文件有读写权限。
wb+	以二进制格式、读写模式打开文件，一般用于非文本文件
a	以追加模式打开一个文件，对文件只有写入权限，如果文件已经存在，文件指针将放在文件的末尾（即新写入内容会位于已有内容之后）；反之，则会创建新文件。
ab	以二进制格式打开文件，并采用追加模式，对文件只有写权限。如果该文件已存在，文件指针位于文件末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。
a+	以读写模式打开文件；如果文件存在，文件指针放在文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。
ab+	以二进制模式打开文件，并采用追加模式，对文件具有读写权限，如果文件存在，则文件指针位于文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。

文件打开模式，直接决定了后续可以对文件做哪些操作。例如，使用 r 模式打开的文件，后续编写的代码只能读取文件，而无法修改文件内容。