大部分参考自菜鸟教程
文中出现的代码，带>>的代码为交互式命令行，其他为脚本
目录
前言：运行python
1、交互式命令行：
你可以通过命令行窗口进入 Python 并开始在交互式解释器中开始编写 Python 代码。
你可以在 Unix、DOS 或任何其他提供了命令行或者 shell 的系统进行 Python 编码工作。
$ python # Unix/Linux 或者 C:>python # Windows/DOS
交互式解释器可以充当计算器：输入2+3.3，按下回车，命令行给出结果5.3
>>> 2+3.3
5.3
2.命令行中运行脚本
3.IDE：pycharm
正文
1.注释
#单行注释
'''
多行注释1
'''
"""
多行注释2
"""
2.代码块
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。
if True:
print ("Answer")
print ("True")
else:
print ("Answer")
print ("False") # 缩进不一致，会导致运行错误3.多行语句
如果语句很长，我们可以使用反斜杠 \ 来实现多行语句
#total = item_one +item_two +item_three
total = item_one + \
item_two + \
item_three4.数据类型
数值、字符串、元组是不可变类型（immutable），集合、列表、字典是可变（mutable）类型。
可变类型的变量，可以修改变量元素，也可以重新对整个变量赋值；
而不可变类型的变量，只能对整个变量重新赋值，以达到修改变量的目的。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
1.pycharm上运行时，Python出于对性能的考虑，但凡是不可变对象，在同一个代码块中的对象，只要是值相同的对象，就不会重复创建，而是直接引用已经存在的对象。
2.但若使用b=a这一赋值语句，不论是什么变量，ab都指向同一内存。
关于python中b=a与b=a[:]的区别_XD_whYe的博客-CSDN博客
Python 中的变量不需要声明。每个变量在使用前都必须赋值.若不给变量赋值，则会出错。
在 python 中，类型属于对象，对象有不同类型的区分，变量是没有类型的：
a=[1,2,3] a="Runoob"
以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。
| 数据类型 | |
| number 数字 | 1.int ：0101，62，0x80，232232446 2.float：3.15，4.2E-10 3.complex（复数）：2i+3 |
| bool 布尔类型 | 数值只有True，False两种。 若bool型参与数字运算，True对应数字1，False对应数字0。 True==1，False==0
|
| string 字符串 | a：python中' '和" "等价。 b：使用三引号(''' 或 """)可以指定一个多行字符串。 c：转义符 \。使用 r 可以让反斜杠不发生转义，如r"this is a line with \n" 则 \n 会显示，并不是换行。 d：字符串可以用 + 运算符连接在一起，用 * 运算符重复。 e：Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。 f：Python 中的字符串不能改变。 g：Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。 h：字符串的截取的语法格式如下：变量[头下标i:尾下标j:步长] 截取的字符串包含i，不包含j（见实例1） |
| list 列表 [值] | 见4.1 |
| tuple 元组 (值) | 见4.2 |
| set 集合 {值} | 见4.3 可以进行差并交集运算 |
| dictionary 字典 {键值对} | 见4.4 |
创建空变量
| 空列表 | tinylist = list（） tinylist2 = [] |
| 空元组 | tinytuple=（） |
| 空集合 | tinyset=set（） |
| 空字典 | tinydict={} tinydict2=dict（） |
del语句可以删除某个元素或某个对象，这对于任何数据类型都是通用的
>>> a= list("21553")
>>> a
['2', '1', '5', '5', '3']
>>> del a[1]
>>> a
['2', '5', '5', '3']
>>> del a
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
4.1字符串
4.1.1.字符串格式化
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
print("25的八进制形式为%o"%25)
#输出结果
25的八进制形式为31字符串格式化符号
操作符辅助指令
4.1.2.f-string
在python3.6后添加了一种格式化字符串的方式：f-string 格式。
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将①变量或②表达式计算后的值替换进去
#①
a = "123"
print(f"{a}456")
#输出结果
123456
#②
print(f"2的3次方为{2**3}")
#输出结果
2的3次方为84.1.3. str.format()函数
区别于前两种的方式。format 函数可以接受不限个参数，位置可以不按顺序。
#基础格式
print("{},{}".format("你好","世界"))
#指定位置
print("{1},{0}".format("你好","世界"))
#设置参数
print("{hello},{world}".format(hello="你好",world="世界"))
#通过列表索引设置参数
initstr = ["你好","世界"]
print("{0[0]},{0[1]}".format(initstr))#0不可省略
#通过字典设置参数
dict = {"hello":"你好","world":"世界"}
print("{hello},{world}".format(**dict))#**表示字典
#传入对象
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
输出结果
你好,世界
世界,你好
你好,世界
你好,世界
你好,世界
value 为: 6
使用大括号转义大括号
print("{},{{0}}".format("1"))
#输出结果
1,{0}str.format()格式化数字的方法
注意：（字符串）
#""" """独立出现表示多行注释
"""
这是
多行注释
"""
#""" """用作变量表示多行字符串
paragraph = """这是一个段落，
可以由多行组成"""para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
#以上实例执行结果为：
'''
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
'''实例1：字符串的多种输出方式
str='123456789'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始后的所有字符
print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
#实例输出结果
"""
123456789
12345678
1
345
3456789
24
123456789123456789
123456789你好
"""实例2：用命令行得到字符串包含的字符个数
import sys; x = 'runoob'
sys.stdout.write(x)
#执行结果
"""
runoob
6
"""
#6为字符串中字符个数4.2列表
1.列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']2.列表截取的语法格式如下：
变量[头下标i:尾下标j：步长] #索引值以 0 为开始值，-1 为从末尾的开始位置。#同字符串一样，截取所得元素包含i不包含j
3.列表可以用 + 运算符连接在一起，用 * 运算符重复。
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表
#运行结果
'''
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
'''4.与Python字符串不一样的是，列表中的元素是可以改变的。
5.列表的一些方法
使用append方法和pop方法，列表可以当作栈使用
>>> stack = []
>>> stack.append(1) #入栈
>>> stack.append(2) #入栈
>>> stack
[1, 2]
>>> stack.pop() #出栈
2
>>> stack
[1]
同样地， 使用append方法和pop（0）方法，列表可以当作队列使用.但pop（0）速度并不快，因为所有元素都要移动。
6.矩阵
使用列表构造矩阵，并通过推导式将矩阵转置
>>> matrix = [[0,0,0,0],
... [1,1,1,1],
... [2,2,2,2]]
>>> matrix = [[row[i] for row in matrix]for i in range(3)]>>> matrix
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]
4.3元组
元组与列表基本类似，不同之处主要有2个。
1.元组写在小括号 () 里，元素之间用逗号隔开。
输入元组时，可以不写小括号
tuple = 1,2,3,4
但输出时，元组是带小括号的
>>> tuple
(1, 2, 3, 4)
2.元组同字符串一样，元素不可改变。
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')1.创建空元组
tup1 = ()2.元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
3.元组是不可变的。
即元组中的元素值是不允许修改的，但可以重新对变量赋值
# 以下修改元组元素操作是非法的。
tup1[0] = 100#以下操作可行
tup = ('r', 'u', 'n', 'o', 'o', 'b')
tup = (1,2,3)4.元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup = ('Google', 'Runoob', 1997, 2000)
del tup5.与列表一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
6.元组和列表一样具有索引，可以进行截取
>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
4.4集合
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
#两种创建集合的方法
#方法一
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
#方法二
a = set('abracadabra')
#更多实例
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites) # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Runoob' in sites :
print('Runoob 在集合中')
else :
print('Runoob 不在集合中')
# 可以进行集合运算
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 中不同时存在的元素
#以上实例输出结果：
'''
{'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
Runoob 在集合中
{'b', 'c', 'a', 'r', 'd'}
{'r', 'b', 'd'}
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
{'c', 'a'}
{'z', 'b', 'm', 'r', 'l', 'd'}
'''
注意：set函数创建空集合，{}创建空字典。set函数只能有一个参数
set1 = set（） #空集合
dict={} #空字典
person2 = set(("hello","jerry",133,11,133,"jerru")) #只能传入一个参数，可以是list,tuple等 类型>>> list = set("dsdadsada")
>>> list
{'s', 'a', 'd'}
1.添加元素 s为一个集合
s.add( x )s.update( x )
2.移除元素
s.remove( x )s.discard( x )s.pop() #随机删除一个元素s.clear()#清空集合
3.计算集合元素个数
len(s)
4.5字典
列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，列表通过偏移存取。
调用字典元素：dictionary[键名]
调用列表元素：list[下标]
字典；是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
1.创建字典
#两种创建字典的方法
#方法一
tinydict = {'name': 'bob', 0: 'false'}
#方法二
tinydict = dict(a='a', b='b', t='t')
tinydict2 = dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) #dict（）参数为键值对元组列表2.字典赋值
#两种字典赋值方法
#方法1
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
#方法2
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}3.删除字典
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典4. 如果同一个键出现两次，则它的值是最后一次赋的值
tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print ("tinydict['Name']: ", tinydict['Name'])
#
以上实例输出结果：
tinydict['Name']: 小菜鸟5.遍历字典
>>> tel = {'jack': 4098, 'sape': 4139}
>>> for x in tel :
... x
...
'jack'
'sape'
直接使用for循环遍历字典只会显示键，使用 items() 方法同时遍历键和值
>>> for x,y in tel.items():
... x,y
...
('jack', 4098)
('sape', 4139)
附加：遍历列表的技巧
在列表中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
同时遍历两个或更多的列表，可以使用 zip() 组合：
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
6.更多实例
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
#输出结果
'''
1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])
'''键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
5.数据类型转换
Python 数据类型转换可以分为两种：
- 隐式类型转换 - 自动完成
- 显式类型转换 - 需要使用类型函数来转换
·int()中base为进制，使用base时，x不能是数字
int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，且必须是整数
#12 为 18的16进制形式6.python推导式
Python 支持各种数据结构的推导式：
- 列表(list)推导式
- 字典(dict)推导式
- 集合(set)推导式
- 元组(tuple)推导式
[表达式 for 变量 in 列表] [out_exp_res for out_exp in input_list] 或者 [表达式 for 变量 in 列表 if 条件] [out_exp_res for out_exp in input_list if condition]
- out_exp_res：列表生成元素表达式，可以是有返回值的函数。
- for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
- if condition：条件语句，可以过滤列表中不符合条件的值。
7.运算符
7.1算术运算符
7.2比较运算符
7.3赋值运算符
不同变量同时赋值
a，b，c = 1，2，"xx"
或
a=1;b=2;c="xx" #用;分割一行的多个语句
7.4位运算符
a=60，b=13
7.5逻辑运算符
7.6成员运算符
7.7身份运算符
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
>>>a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True
691
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
