python基础语法

python基础知识

1 python概述

1.1优点

1.开源，易于维护。

2.可移植。

3.易于使用，简单优雅。

4.广阔的标准库，功能强大。

5.可扩展，可嵌入。

1.12劣势

1.运行速度慢。(解释型语言，翻译为机器码耗时)

2.代码不能加密。(发布程序为源代码)

2 python语法

2.1注释

1. 单行注释：

   #这是一个单行注释
   

2. 多行注释：

   '''
   这是一个多行注释
   这是一个多行注释
   '''
   

---

3 基础语句

3.1 输出print语句

print(“具体的字符”)
print(变量名)

print(“xxxxx %变量类型缩写” %变量名)

#具体输出
print("具体的字符")
#变量输出
int a=10
print(a)
#格式化输出
print("输出%d具体字符"%a)
#连接符
print("具体字符","具体字符","具体字符",sep="分隔符(默认为空格)")
print("",end="")#直接连接后方字符串
print("",end="\t")#空格后链接后方字符串
print("",end="\n")#换行后链接后方字符串

格式符号	转换
%c	字符
%s	通过str()字符串来格式化
%i	有符号十进制整数
%d	有符号十进制整数
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数(小写字母)
%X	十六进制整数(大写字母)
%e	索引符号(小写’e’)
%E	索引符号(大写’E’)
%f	浮点实数
%g	%f和%e的简写
%G	%f和%E的简写

3.2 输入input语句

接受输入的变量名 = input("提示信息")

---

4 变量及类型

变量名可以是任意数据类型，在程序中用一个变量名表示

变量名必须有 大小写英文，数字，和下划线(_)组成

赋值(a=“ABC”)时，python解释器执行了两个操作:

1. 在内存中创建了一个"ABC"的字符串
2. 在内存中创建了一个名为a的变量，并把它指向了"ABC"

---

5 运算符

5.1 算数运算符

运算符	描述
+	加-两个对象相加
-	减-得到复数或是一个数减去另一个数
*	乘-两个数相乘或是返回一个被重复若干次的字符串
/	除-X除以Y
%	取模-返回除法的余数
**	幂-返回x的y次幂
//	取整数- 向下取接近除数的整数

5.2 比较运算符

运算符	描述
==	等于-比较对象是否相等
!=	不等于-比较两个对象是否不相等
>	大于-返回X是否大于Y
<	小于-返回X是否小于Y(所有比较运算符返回1为真，返回0表示假)
>=	大于等于-返回X是否大于等于Y
<=	小于等于-返回X是否小于等于Y

5.3 赋值运算符

运算符	描述
=	等于- a=1
+=	加法赋值语句-“a+=b” = “a=a+b”
-+	减法赋值语句-“a-=b” = “a=a-b”
*=	乘法赋值语句-“a*=b” = “a=a*b”
/=	除法赋值语句-“a/=b” = “a=a/b”
%=	取模赋值语句-“a%=b” = “a=a%b”
**=	幂赋值语句-“a* *=b” = “a=a * *b”
//=	加法赋值语句-“a//=b” = “a=a//b”

5.4 位运算符

运算符	描述
&	按位与运算符-参与运算的两个值相应位为1则结果为1，否则为0
|	按位或运算符-参与运算的其中一个值为1，结果为1.
^	按位异或运算符-当两相应的二进制位相异时，结果为1.
~	按位取反运算符-对数据的每个二进制位取反，即把1变为0，把0变为1.
<<	左移动运算符-运算数的各二进制位全部左移若干位由"<<"指定移动的位数。
>>	右移动运算符-运算数的各二进制位全部右移若干位由"<<"指定移动的位数。

5.5 逻辑运算符

运算符	描述
and	布尔"与"-
or	布尔"或"-
not	布尔"非"-

5.6 成员运算符

运算符	描述
in	如果在指定数列中找到值返回true,否则返回falst
not in	如果在指定数列中没有找到值返回true,否则返回falst

5.7 运算符的优先级

运算符	描述
**	指数（最高优先级）
* / % //	乘,除,取模，取整数
±	加，减
>> <<	左移右移
&	位（and）
^ |	位运算符
<= << >> >=	比较运算符
<> == !=	等于运算符
= += -= *= /= %= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
and or not	逻辑运算符

---

6 条件判断语句

python 指定任何非0和非空值为true ，0或者None为falst

条件判断语句以缩进控制范围

if 判断语句：#缩进必须同级相同，要不不识别 

	执行语句1

elif 判断语句2：
	执行语句2
else：
	执行语句3

---

7 循环语句

7.1 for循环

for i in range(5)：#从0开始五个数的数组
	循环语句
for i in range(0,10,3)：#从0开始到10为止，步进值为3
	循环语句
a = ["1","2","3"]
for i in range(len(a))
	print(i,a[i])

for i,x in enumerste(列表)
	print(i,x)  					#枚举函数，i为索引，x为列表值

7.2 while循环

i = 0
while i < 5:
    循环语句
    i = i++
else:
    循环语句

7.3循环控制 break continue pass

#break 退出循环语句
#continue 跳过当前循环
#pass 占位符

---

8 字符串，列表，元组，字典

8.1 字符串

python 中的字符串可以使用单引号，双引号和三引号括起来，使用反斜杠\转义特殊字符

python3源码文件默认以UTF-8编码，所有字符串都是unicode字符串

支持字符拼接，截取等多种运算

字符串中出现单引号和双引号时需要前加\转义

word = '字符串'
word1 = "字符串"
word2 = """
		字符段落
"""

8.1.1 str[x,y,z]

str = "字符串"
print(str[x:y:z])  #@x为起始值，从零开始，y为结束值，不打印结束值，z为步进值。

8.1.2字符串连接

str1 = "字符串"
str2 = "字符串"
print(str1 + str2)

8.1.3字符串的常见操作

方法	描述	描述
capitalize	将字符串第一个字符转换为大写
bytes.decode(encoding=“utf-8”,errors=“strict”)	Python3中没有decode方法，但是我们可以使用bytes对象的decode（）方法来解码给定的bytes对象，这个bytes对象可以由str.encode()来编码返回。
encode(encoding=“utf-8”,errors=“strict”)	以encoding指定的编码格式编码字符串，如果出错默认报一个VaError的异常，除非errors指定的是’ignore’或者’replce’
isalnum()	如果字符串中至少有一个字符并且所有字符都是字母或者数字则返回True,否则返回Falst.
isalpha()	如果字符串中至少有一个字符并且所有字符都是字母则返回True,否则返回Falst.
isnumeric()	如果字符串中只包含数字字符，则返回True，否则返回Falst。
isdigit()	如果字符串中只包含数字字符，则返回True，否则返回Falst。
join(分隔符)	以指定字符串为分隔符，将所有元素合并为一个新的字符串。
len(string)	返回字符串的长度。
lstrip()	截掉字符串左边的空格或指定字符。
rstrip()	删除字符串末尾的空格
split(str="",num=string.count(str)num=string.count(str))	以str为分隔符截取字符串，如果num有指定值则只截取num+1个字符串。

---

8.2 列表(list)

列表可以完成大多数集合类的数据结构实现。列表中的元素的类型可以不相同，它支持数字，字符串，甚至可以包含列表(所谓嵌套)。

列表是写在方括号[]之间,用逗号分隔开的元素列表。

列表索引值以0为开始值，-1为末尾的开始位置。

列表可以使用+操作符进行拼接，使用*操作符进行重复。

支持 in count 方法

list = ["字符串",0,[]]  #@可以存在混合类型

8.2.1 列表方法

方法	描述	备注
append()	在末尾添加元素	list.append([1,2])-- list = [ 1 , 2 , [1 , 2]]
extend()	在末尾添加元素	list.extend([3,4]) – list = [ 1 , 2 , 3 , 4]
insert()	在指定位置插入
del 列表名	删除列表
pop()	弹出列表元素
index()	查询指定范围内是否存在
count()	查询某个元素出现几次
reverse()	反转排序
sort()	从小到大排序
sort(reverse=True)	从大到小排序
remove()	删除指定内容的元素

8.2.2 列表方法介绍

1. 增：

   list = [1,2]
   
   #在末尾追加元素 append()方法--列表名.append(要添加的字符)         
   list.append("要增加的字符")
   

!!! list.append([1,2]) ---------- list = [ 1 , 2 , [1 , 2]]

#在末尾追加元素 extend()方法–列表名.extend(要追加的元素)
list.extend([元组元素，元组元素])
!!! list.extend([3,4]) ---------- list = [ 1 , 2 , 3 , 4]

#在指定位置插入 insert()方法–列表名.insert(要插入位置的下标，插入的元素)
list.insert(插入索引，插入元素)

2.删：

```python
list = [0,1,2,3]

#在指定位置删除元素 del方法--del 列表名[要删除元素的索引]
del list[索引]

#弹出最后一个元素 pop方法--列表名,pop()
list.pop()

#删除指定内容的元素 remove()方法--列表名.remove("要删除元素的具体内容")
list.remove("指定内容")   #从前开始遍历，优先删除最前方的。

3.改：

list = [1,2,3]

#指定元素进行修改 无具体方法--列表名[修改元素索引] = "具体内容"
list[索引] = ""

4.查：

list = [1,2]
 
#查询指定元素是否在列表中 if判断-if 元素 in 列表：
if 1 in list:
    反馈语句

#查询指定范围内是否存在 index()方法--列表名.index(指定元素，开始元素，结束元素) ！！！左包含右不包含
list.index(指定元素,开始，结束(不包含))  #@存在返回索引，不存在报错

#查询某个元素出现几次 count()方法--列表名.count(元素具体值)
list.count("元素具体值")

5.排：

list = [1,2,3,4]

#反转排序 reverse()方法--列表名.reverse()
list.reverse()         #@反转列表顺序

#从小到大排序 sort()方法--列表名.sort()
list.sort()           #@从大到小排序

#从大到小排序 sort(reverse=True)方法--列表.sort(reverse=True)
list = sort(reverse=True) #@从大到小排序

 

8.2.3 列表的嵌套

list = [[1,2],[3,4],[5,6]]

列表名[索引][索引] list[索引][索引]

---

###8.3 元组(tuple)

元组(Tuple)与列表相似，不同之处是元组中的元素不能修改。写在小括号中，元素之间用逗号隔开。

元组的元素不可变，但是可以包含可变对象，如列表

！！！tuple = (0)时，type(tuple) 时int型的，只有tuple = (0,)时type(tuple) 时tuple型的

支持 in count 方法

8.3.1 元组方法

方法	描述	备注
len()	获取元组长度
max()	获取元组元素最大值
min()	获取元组元素最小值
tuple()	将其他类型对象转换为元组
del 元组名	删除元组

8.3.2 元组方法介绍

1.增：

tuple = (1,2,3,4)

#并不是在某一个上增加了，而是新建了。
tup2 = (元素) 
tup1 =（元素）
tup = tup1 + tup2

2.删：

tuple = (1,2,3,4)

#删除整个元组  del 元组名
del tuple

3.查：

tuple = (1,2,3,4)
#查找具体元素  元组名[索引]
tuple[索引]

---

8.4 字典(dict)

字典时无序的对象的集合，使用键值对存储(key-value)，具有极快的查找速度。

键(key)必须使用不可变的类型。

同一字典中，键(key)必须唯一。

8.4.1方法

方法	描述	备注
len()	获取字典长度
max()	获取最大key
min()	获取最大value
dict()	将其他类型转换为字典 dict( [ (1,2),(1,2) ] )
get()	查找指定键的值	未查找到不报错，可以设定默认值
keys()	查找所有键
values()	查找所有值
items()	查找所有键值
del 字典名	删除字典
clear()	清除字典

8.4.2字典的具体操作

1.查：

info = {
     "key":"value","key1":"value"}

#查找指定键的值  字典名["字典中具体的键"]
info["key"]				#如果访问不存在的键会报错

#查找指定键的值  get()方法--字典名.get("字典中具体的键","如果未查询到，返回的值")
info.get("key")			#如果不存在返回None
info.get("key","设定默认值")			#如果不存在返回设定的值，如果找到默认值不发挥作用。

#查找所有键  keys()方法--字典名.keys()
info.keys()                #返回所有键(列表)

#查找所有值  values()方法--字典名.values()
info.values()                #返回所有值(列表)

#查找所有键值  items()方法--字典名.items()
info.items()                #返回所有键值(列表)---[(键，值),(),()]
for key,value in 字典名,items():
    print("key=%s,value=%s",%(key,value))

2.增：

info = {
     "key":"value","key1":"value"}

#增加新的键值对  字典名["键"] = 值
info["key2"] = "value"

3.删：

info = {
     "key":"value","key1":"value"}

#删除指定键值对。 del方法 --del 字典名["指定值"]
del info["key"]          #删除整个键值对，删除后再访问报错。
del info                 #删除字典，再访问报错。

#清空字典  clear()方法 --字典名.clear()
info.clear()

4.改：

info = {
     "key":"value","key1":"value"}

#更改键对应的值    字典名["键"] = ”值“
info["key"] = "值"

---

8.5集合(set)

集合和字典类似，也是一组key的集合，但是不存在存储value。由于key不能重复，所以，再set中，没有重复的key。

set是无序的，重复元素再set中自动被过滤。

8.5.1方法

方法	描述	举例
for循环	遍历集合
update()	更新集合	集合名.update(集合名)
add()	向集合中添加元素	集合名.add(元素)
remove()	移除集合中的元素	集合名.remove(元素)
pop()	弹出元素	集合名.pop(元素)
clear()	清除集合中的元素	集合名.clear()
del	删除集合	del 集合名
len()	获取集合长度	集合名.len()
max()	获取最大值	集合名.max()
min()	获取最小值	集合名.min()
set()	将其他类型转换为集合	set()

8.6 总结

类型	是否有序	是否可变
列表[]	有序	可变类型
元组()	有序	不可变类型
字典{}	无序	key不可变,value可变
集合{}	无序	可变类型（不可重复）

---

9 转义字符

有些字符无法在语句中直接使用，需要转义后才能使用。

转义字符	描述
(在行尾时)	续行符
\\	反斜杠符号
\’	单引号
\"	双引号
\a	响铃
\b	退格
\000	空格
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表字符，列如：\o12代表换行，其中o是字母	。
\xyy	十六进制数，yy代表的字符，列如：\x0a代表换行。

print("字符串")#@字符串中的\为转义字符，进行转义。
print(r"字符串")#@要打印的字符串前加 r 表示字符串其中转义\不进行转义，直接输出。

10 函数

10.1 概念

1.开发程序时，需要某块代码多次，但是为了提高编写效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。

2.函数可以有多个return 但是只要执行一个return就算函数调用完成。

3.函数名不能重复。

4.带参函数，如果在定义时有形参，那么在调用时就应该传递参数

5.调用时，实参的个数和先后顺序应该和定义函数中的要求一致。

#不带参数
del 函数名():
    函数体(pass)

#带参数
del 函数名(参数1,参数2):
    函数体(pass)

#带返回值-------只有有return才有返回值
del 函数名(参数1,参数2):
    函数体(pass)
	return 参数
变量名 = 函数名()    		   #接收单返回值
del 函数名(参数1,参数2):
    函数体(pass)
	return 参数,参数
变量名,变量名 = 函数名()     #接收多个返回值

10.2 全局变量和局部变量

全局变量：在整体函数上声明的变量，可以在所有函数上使用。

局部变量：在函数体中声明的变量，只能在本函数上使用。

在函数中，全局变量和局部变量同名时，优先使用的是局部变量，要使用全局变量需要在声明之前加 global 关键字

a = 1			##全局变量
del 函数名（）：
	a = 2		##局部变量，会被优先修改
print(a)		##结果为1

a = 1			##全局变量
del 函数名（）：
	global a = 2		##声明使用全局变量
print(a)		##结果为2

11 文件

11.1 文件操作

1.打开

##打开指定路径，文件名的文件，使用设定的模式。
变量名1 = open("文件名","打开模式")

2.关闭

变量名1 = open("文件名","打开模式")

#关闭已经打开的文件。
变量名1.close()

3.读

变量名1 = open("文件名","打开模式")

#读取打开文件指定字符的内容	read()方法--打开文件的变量名.read(读取字符个数)
#read()方法开始定位在文件头，每执行一次向后移动指定字符。
变量名1.read(5)    	#读取五个字符
变量名1.read(5)		#会继续往后读取5个字符，与上一句代码读取不相同 ！！！！！！

#读取打开文件所有行的内容 readlines()方法--打开文件的变量名.readlines()
变量名1.readlines() 		#返回每行一个元素的列表

#读取打开文件指定行的内容 readline()方法--打开文件的变量名.readline()
#readline()方法开始定位在文件头，每执行一次向后移动指定行。
变量名1.readline() 		#返回每行一个元素的列表

4.文件重命名

引入os模块，使用os中的rename()进行文件重命名。

import os

#文件重命名  rename()方法--os.rename("需要修改的文件名","新的文件名")
os.rename("旧文件名","新文件名")

5.删除文件

引入os模块，使用os中的remove()进行文件删除。

import os

#文件删除  remove()方法--os.remove("要删除的文件名")
os.remove("要删除的文件名")

11.2打开模式

访问模式	说明	备注
r	以只读的方式打开文件。文件的指针将会放在文件的开头。这是默认的模式。	如果不存在文件会报错
w	打开一个文件只用于写入。如果该文件已经存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加，如果该文件已经存在，文件指针将会放在文件的结尾，也就是说，新的内容会被写到已有的内容之后，如果该文件不存在，创建新文件进行写入。
rb	以二进制格式打开一个文件用于只读，文件指针将会放在文件的开头。这是默认的模式。
wb	以二进制格式打开一个文件用于写入，文件的指针将会放在文件的开头。这是默认的模式。
ab	以二进制格式打开一个文件用于追加，文件指针将会放在文件的结尾，也就是说，新的内容会被写到已有的内容之后，如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写，文件的指针将会放在文件的开头。
w+	打开一个文件用于读写，如果该文件已经存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写，如果文件存在，文件指针将会放到文件的结尾，文件打开时会是追加模式。如果文件不存在，创建新文件用于读写。
rb+	以二进制格式打开一个文件用读写。文件指针将会放在文件开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已经存在则将其覆盖，如果该文件不存在则创建新的文件。
ab+	以二进制格式打开一个文件用于读写。如果文件已存在，文件指针将会放到文件的结尾。如果文件不存在，创建新的文件用于读写。

---

12 异常

异常指的是在程序运行过程中发生的异常事件，通常是由外部问题（如硬件错误、输入错误）所导致的。在Java等面向对象的编程语言中异常属于对象。

捕获异常：try: #@可能出现异常的代码放在try中

处理异常:except 捕获异常类型： #@处理异常的代码放在except中

try 可以嵌套

异常处理的常用操作：

#捕获单个异常
try:
    可能发生异常的代码块
except 可能发生的异常类型 ：
	若发生异常时执行的语句
    
#捕获多个异常
try:
    可能发生异常的代码块
except （异常1，异常2）：		#将可能出现的异常填写在小括号中
	若发生异常时执行的语句

#捕获多个异常
try:
    可能发生异常的代码块
except （异常1，异常2）as result：			#result 错误信息
	若发生异常时执行的语句
    print(result)				#打印错误信息，错误信息以字符串形式被打印

#捕获通用异常
try:
    可能发生异常的代码块
except Exception as result：		# Exception可以承接任何异常，可以打印result错误信息，也可以不打印错误信息。
	若发生异常时执行的语句
    print(result)
    
#try------finally  finally:后的代码不论异常是否发生，都会执行
try:
    可能发生异常的代码块
except 可能发生的异常类型 ：
	若发生异常时执行的语句
finally:
    不论是否异常都执行的代码

---

常用方法

random.randint(起始值，结束值) 随机生成int型数