一、注释
1.单行注释：# 开头
2.多行注释：''' 和 """
二、缩进
python是使用缩进来表示代码块，不需要使用大括号{}
python具有严格的缩进原则，每个缩进一般可以有两个或四个空格组成，也可以是任意数量的空格，因为缩进的空格数是可变的，但同一个代码块必须保持相同的缩进空格数。
三、多行语句
在一行中的多行语句，用；分隔
四、输入输出
1.输入：
input("输入")2.输出：print默认输出使换行的，如果要实现不换行，在变量末尾加上end=”“
五、导入模块
在 python 用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
六、字符串
1.单引号‘和双引号”包起来的都是字符串，因为python中没有单独的字符类型
2.使用三引号(''' 或 """)可以指定一个多行字符串，或者说是段落
3.+用来连接字符串，*表示字符串的重复次数
4.对于字符串还有截取的语法
5.在字符串前加’r'，就可以让转义字符不起作用
七、运算符
1.算数运算符
+，-，*，/，%都是和其他语言一样（其中/得到的答案是小数）
特殊的有： ** 幂，//去整除-往小的方向去整数
2.比较运算符
==，！=，>,<,>=,<= 用法都与其他语言一样
3.赋值运算符
= 普通赋值运算符
+= 加法赋值运算符
-= 减法赋值运算符
*= 乘法赋值运算符
/= 除法赋值运算符
%= 取模赋值运算符
**= 幂赋值运算符
//= 取整赋值运算
4.位运算符
1.<< :
左移运算符，运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
a << 2 输出结果 240 ，二进制解释： 1111 0000
2.>>:
右移动运算符,把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数
a >> 2 输出结果 15 ，二进制解释： 0000 1111
3.&:
按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
4.|:
按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
5.^:
按位异或运算符：当两对应的二进位相异时，结果为1
6.~:
按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1
5.逻辑运算符
假设变量 a 为 10, b为 20
and，布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。
(a and b) 返回 20。
or，布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
(a or b) 返回 10。
not，布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。
not(a and b) 返回 False
#!/usr/bin/python3
a = 10
b = 20
if ( a and b ):
print ("1 - 变量 a 和 b 都为 true")
else:
print ("1 - 变量 a 和 b 有一个不为 true")
if ( a or b ):
print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print ("2 - 变量 a 和 b 都不为 true")
# 修改变量 a 的值
a = 0
if ( a and b ):
print ("3 - 变量 a 和 b 都为 true")
else:
print ("3 - 变量 a 和 b 有一个不为 true")
if ( a or b ):
print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print ("4 - 变量 a 和 b 都不为 true")
if not( a and b ):
print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
print ("5 - 变量 a 和 b 都为 true")6.成员运算符
成员运算符的使用对象包括 字符串，列表或元组
in ： 如果在指定的序列中找到值返回 True，否则返回 False。
x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in :如果在指定的序列中没有找到值返回 True，否则返回 False。
a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
if ( a in list ):
print ("1 - 变量 a 在给定的列表中 list 中")
else:
print ("1 - 变量 a 不在给定的列表中 list 中")
if ( b not in list ):
print ("2 - 变量 b 不在给定的列表中 list 中")
else:
print ("2 - 变量 b 在给定的列表中 list 中")
# 修改变量 a 的值
a = 2
if ( a in list ):
print ("3 - 变量 a 在给定的列表中 list 中")
else:
print ("3 - 变量 a 不在给定的列表中 list 中")7.身份运算符
is 是判断两个标识符是否引用自一个对象，x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True
is not 与 is 的作用相反
a = 20
b = 20
if ( a is b ):
print ("1 - a 和 b 有相同的标识")
else:
print ("1 - a 和 b 没有相同的标识")
if ( id(a) == id(b) ):
print ("2 - a 和 b 有相同的标识")
else:
print ("2 - a 和 b 没有相同的标识")
# 修改变量 b 的值
b = 30
if ( a is b ):
print ("3 - a 和 b 有相同的标识")
else:
print ("3 - a 和 b 没有相同的标识")
if ( a is not b ):
print ("4 - a 和 b 没有相同的标识")
else:
print ("4 - a 和 b 有相同的标识")结果： 1 - a 和 b 有相同的标识 2 - a 和 b 有相同的标识 3 - a 和 b 没有相同的标识 4 - a 和 b 没有相同的标识
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
八、列表
列表是Python中最基本的数据结构，它可以作为一个方括号内的逗号分隔值出现
相当于c语言中的数组，但相比数组，列表中的元素可以是任意类型
list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 已经内置确定序列的长度以及确定最大和最小的元素的方法
1.访问列表中的值
索引可以是从头部开始0，1，2···，也可以是从尾部开始-1（最后一个元素），-2，···
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[-1] )
print( list[-2] )输出结果：
red
green
black
white
另外除了下标检索的方法，可以使用方括号 [ ] 的形式截取字符
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])输出结果：
[10, 20, 30, 40]
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])还有一种截取形式
L[1:] ['Runoob', 'Taobao'] 输出从第二个元素开始后的所有元素
2.更新列表
可以直接对列表的元素进行更新，使用append()方法来添加列表元素
list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)输出结果：
第三个元素为 : 1997 更新后的第三个元素为 : 2001 更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']
3.删除列表元素
使用到del语句来删除列表的元素
#!/usr/bin/python3
list = ['Google', 'Runoob', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)4.列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
5.嵌套列表
即一个列表的元素是其他的列表
>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'6.列表比较
列表比较需要引入 operator 模块的 eq 方法
# 导入 operator 模块
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))输出结果：
operator.eq(a,b): False operator.eq(c,b): True
九、元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>python中元组和列表的创建都是通过键值对的形式
>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>1.元组的访问
元组的创建使用到的是括号，但访问元素使用到的是中括号【 】
与列表的访问方式相同
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])2.修改元组
这里是和列表不一样的了
元组是不允许修改其内部的元素
元组的删除和列表一样使用del语句，但元组不能删除其中的元素，只能删除整个元组
tup=('google','123123')
del tup
3.元组运算符、内置函数均与列表的操作相同
十、字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中
列表的创建用【】，元组的创建用（ ）
字典类似于C中的结构体，容器中的每个元素的标识不是下标，而是”键“
1.字典的创建
1）使用{ }来创建字典
emptydict= {} #用{}来创建空的字典
print(emptydict) #打印字典
print("length:" , len(emptydict)) #查看字典长度2）用内建函数dict()创建字典：
emptydist = dict()
print(emptydist)
print('length:' , len(emptydist))我觉得用第一种方法创建字典比较简单
2.访问字典
把相应的键放入方括号中
emptydict = {'name':'张三','age':'17','class':'first'}
print(emptydict['name'])
print(emptydict['age'])3.修改字典
emptydict = {'name':'zhangsan','age':'17','class':'first'}
emptydict['nickname'] = 'zhangliu' #添加信息
emptydict['age'] = '18' #更新信息4.删除字典
tinydict = {'name':'zhangsan','age':18}
del tinydict['age'] # 删除键age
tinydict.clear() # 清空字典
del tinydict # 删除字典
十一、集合
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
parame = {value01,value02,...}
或者
set(value)>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}1.元素添加
使用到语法： s.add(x)
将元素x添加到集合s中去，如果元素已存在，不进行任何操作
thisset = set(('google','12341234'))
thisset.add('facebook'))
2.删除元素
使用到语法： s.remove(x)
thisset = set(('gooogle',123123'))
thisset.remove('123123')
thisset.remove('taobao') #不会发生任何变化
3.计算集合元素个数
使用到语法： len（s)
4.清空集合
使用到语法： s.clear()
5.判断元素是否在集合中
x in s
十二、条件控制
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
注意：
- 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
- 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
- 3、在 Python 中没有 switch...case 语句，但在 Python3.10 版本添加了 match...case
十三、循环语句
1.while语句
n=100
sum = 0
counter = 1
while counter <= 1:
sum = sum + counter
counter += 1
print("1 到 %d 之和为：%d " % (n,sum))从上面的示例中，我们看到同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。
而且学到了python中输出语句，想要带有变量的输出（%d），就要是上面的格式
2.for语句
sites = ['baidu', 'google', 'taobao']
for site in sites:
print(site)
word = 'google'
for letter in word:
print(letter)3.for ..else 语句
这里的else子句有些不同，需要注意
for item in iterable:
#循环主体
else:
#循环结束后，执行的代码十四、函数
Python的函数可以有多个参数，可以有多个返回值，可以有默认 参数，可以有可变参数，可以有关键字参数，可以有匿名函数，可以有装饰器。
1.函数定义
函数的定义使用到def关键字
函数的参数可以有默认值，
函数的返回值可以有多个
def add(a,b=1):
return a+b
print(add(1))
def add(a,b=1):
return a+b,a-b
print(add(1))
print(add(1,2))2
(2,0)
(3,-1)
2.关键字参数
函数调用使用关键字参数来确定传入的参数值
使用关键字参数允许参数调用的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
def printinfo(name, age):
print('姓名：',name)
print('年龄：',age)
return
printinfo(age=50,name='张三')3.不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
加了星号*的参数，会以元组的形式导入，存放所有未命名的变量参数
注：
- 在函数调用时，没有指定参数，那它就是空元组
- 用了两个星号**的参数会以字典的形式导入
- 函数声明时，参数中的星号*可以单独出现，如果单独出现星号 *，则星号 * 后的参数必须用关键字传入
def printinfo(arg1,*vartuple):
print('输出：')
print(arg1)
print(vartuple)
printinfo(70,60,50)输出：
70
（60，50）
传入参数是字典形式
def printinfo(arg1,**vardict ):
print('输出：')
print(arg1)
print(vardict)
printinfo(1,a=2,b=3)输出：
1
{‘a':2 , 'b':3}
十五、模块
1.导入模块
Python的模块是⼀种代码的组织⽅式，Python的模块使⽤ import 关键字导⼊， import 关键字后⾯跟模块的名 称
import 后加as，将引入的模块重命名
import前加from，可以将模块内的名称引入，同时可以用as将名称重命名
import math
import math as m
from math import pi
from math import pi as p
from math import *
2.模块属性
import math
print(math.pi)3.141592653589793
3.模块的方法
import math
print(math.sin(1))十六、文件操作
1.打开和关闭文件
file_a = open('student.txt','w+',encoding='UTF-8')
#在这位置写对文件的写操作
file_a.close()
file_a = open('student.txt','r',encoding='UTF-8')
#在这个位置写对文件的读操作
print(file_a.readline())2.w,w+,a,r
w:表示可以写入，而且是覆盖写入
w+:在w的基础上，如果没有这个文件，就先创建这个文件再写入
a:追加写入
r:读文件内容
3.实例
file_a = open('student.txt','w+',encoding='UTF-8')
for i in range(4):
a = input()
file_a.write(a)
file_a.close()
file_a = open('student.txt','r',encoding='UTF-8')
print(file_a.readline())十七、异常处理
a=12
b =0
try:
print(a/b)
except Exception as error:
print(error)
finally:
b=1
print(a/b)十八、类的使用
十九、总结与补充
在python中想要创建变量，像c语言中int a这样的操作，是通过键值对的形式实现的，不需要使用关键字在前面定义
a = 12
b = 0.1
c = '123asdf'列表和元组的区别：
列表和元组中的元素都是可以是任意类型的
a = [1,'2',3,[1,0],(1,0)]列表中的元素可以修改，元组不可以
列表使用【】包含，元组使用（ ）包含
字典和集合的区别
字典和集合都是用{ }包起来的
字典里面的元素是键值对，集合里面的元素是无序的“列表”（会自动消掉重复）
i = {1,1,2,3,3,4}
print(i)输出结果是{1，2，3，4}，因为是集合消掉重复
字典中键如果出现重复，就会选择后面的值
i = {'name':'zhangsan','age':18,'name':'lisi'}
print(i)输出结果是
{'name': 'lisi', 'age': 18}
上面四种数据结构共有的方法，且也是使用次数比较高的
split（） 以某个字符为界，将容器分隔
find（） 查找某个字符的下标位置
count（）记录某个字符出现的次数
replace（）将某个字符替换成另一个字符
b='asdfiasdffj'
a = b.split('i')
c = b.find('a')
d = b.count('f')
e = b.replace('i','0')
f = len(b)
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)输出结果：
['asdf', 'asdffj']
asdfiasdffj
0
3
asdf0asdffj
11
printf("%d",a);python的实现
print('***{}####'.format(a))将变量a的值填空输出在{}的位置，{}与其他连接不需要任何东西，但必须实在引号里的
还有一种是
n = 1
m = 3
print("这个是n:%d,zhege是m:%d"%(n,m))
print("%d"%n)这个中间也就是引号”“后面都是没有逗号‘，’的
6639
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
