1.三引号

多行注释：

"""
第一行注释
第二行注释
第三行注释
"""

跨多行字符串：

str ="""
how are you?
I'm fine.
thank you,and you?
me too!
 """

2.运算符

//表示整除，%求余数，**乘方，floor向上取整，ceil向下取整

2*2
print(2*2)
foo = math.sqrt
foo(4)=2.0

3.输出的格式化方法

format方法

age = 20
name = '海哥'
print('My name is {0} .I am {1} years old'.format(name,age))
print('My name is {name} .I am {age} years old'.format(age =age,name = name))

格式符

# 格式符是有多种
print('My name is %s.I am %d years old.' % ('海哥',20))

缩进

python对缩进格式很严格，缩进不同层次则不同：缩进用Tab或者4个空格来表示。

a = 5
# 行首有一个空格，会出错
 print(a)
# 正确写法
print(a)

# 正确的格式
a = [1,2,3]
for i in a:
    if i>=2:
        print(i)

4.控制流

控制流语句有 if for while（需要在逻辑行的末尾加上:）

a = [1,2,3]
for i in a:
    if i==1:
        print("[1]这是",i)
    elif i==2:
        print("[2]这是",i)
    else:
        print("[3]这是",i)
        
## 输出结果为
# [1]这是 1
# [2]这是 2
# [3]这是 3

5.函数

通过关键字 def 来定义

global语句

global语句用以申明x是一个全局变量

x = 50
def func():
    global x

    print('x is',x)
    x = 2
    print('x is',x)
func()
print('x is',x)

结果：
x is 50
x is 2
x is 2

关键字参数

函数的参数可以不一定要按顺序赋予，可以根据关键字来指定值。

def func(a,b=4,c=10):
    print("a=",a,"b=",b,"c=",c)
func(2,3,4)
func(b=3,a=6,c=3)

结果：
a= 2 b= 3 c= 4
a= 6 b= 3 c= 3

可变参数

可以让函数有任意数量的变量，通过星号(*)实现。

当我们声明一个param的星号参数时，从此处开始直到结束的所有位置参数都将被收集并汇集成一个称为"param"的元组
类似地，当我们声明一个*param的双星号参数时，从此处开始直至结束的所有关键参数都将收集并汇集成一个名为"param"的字典

def total(a=5,*numbers,**phonebook):
    print("a=",a)
    # 遍历元组中的所有项目
    for single_item in numbers:
        print('第二个参数:',single_item)
    # 遍历字典中的所有项目
    for first_part,second_part in phonebook.items():
        print('第三个参数:',first_part,second_part)

total(10,1,2,3,4,JACK=1123,haige=123123)

结果：
a= 10
第二个参数: 1
第二个参数: 2
第二个参数: 3
第二个参数: 4
第三个参数: JACK 1123
第三个参数: haige 123123

DocStrings

首先要求是函数的第一行逻辑行的字符串开始。（也可以是模块或类）

利用'''三引号来规定

可以通过doc函数来获取文档字符串

通过这种方式，当我们引用别人的包，别人的库时，如果不清楚函数的使用，可以通过提供者自己写的文档字符串，快速查看说明使用。

# DocStrings 文档字符串
# 能够帮助你更好记录程序并让其更容易理解
# 只能是函数的第一行逻辑行
def print_max(x,y):
    '''Print the maximum of two numbers.
    The two values must be integers.'''

    x=int(x)
    y=int(y)

    if x>y:
        print(x,'is max')
    else:
        print(y,'is max')

print_max(1,4.5)
print(print_max.__doc__)

结果：
4 is max
Print the maximum of two numbers.
    The two values must be integers.

6.模块

python的模块真的太多太多，太方便了。什么什么爬虫，数据分析，可视化，机器学习用python语言学习很方便，就是因为python的模块化，让我们其他用户可以互相引用。

还可以使用C语言来撰写Python模块，在编译后，可以通过标准Python解释器在自己的项目中使用它

模块的种类

内置模块、第三方模块、自定义模块

模块的name

每个模块都有自己的名称

而在当前运行的py的name默认为main

自然就引出我们平常开发时，调用函数时，得加多一句
当我们写一个模块时，而且为了测试而调用模块下的函数。这时候这个模块有调用函数语句。

当我们在一个py文件要调用这个模块时，这时候我们的py文件就会自动执行该模块的调用语句。

那就很麻烦了，因为我们的目的仅仅是为了引入该模块的方法。

所以为了开发的方便性，我们每次开发项目时，遇到调用方法时，加多以上的if语句，这样可以不断方便被调用。

import 模块名
from 模块名 import 自己定义的变量名
if __name__ = '__main__'

包

包其实就是很多个模块（py文件）组成的。
一个包含模块与一个特殊的init.py文件的文件夹。

7.数据结构

序列

序列的三种形态——列表、元组、字符串

列表

列表用于保存一系列有序项目的集合。类似于购买清单，每件物品都单独列一行，且按逗号隔开。

列表用方括号括起来，一旦创建了，可以添加、移除、搜索列表中的项目。

shoplist = ['banana','apple','water']

# 输出数量
print('I have',len(shoplist),'items to purchase')

# 直接列表输出
print('list output:',shoplist)

# 分别输出
print('There items are:',end=' ')
for i in shoplist:
    print(i,end=' ')

# 添加项目-
print('\nI alse have to buy phone:')
shoplist.append('phone')
print('list output:',shoplist)

# 删除项目
print('I do not want to buy water')
del shoplist[2]
print('list output:',shoplist)

# 给项目排序
print('sort my list:')
shoplist.sort()
print('list output:',shoplist)

结果：
I have 3 items to purchase
list output: ['banana', 'apple', 'water']
There items are: banana apple water 

I alse have to buy phone:
list output: ['banana', 'apple', 'water', 'phone']

I do not want to buy water
list output: ['banana', 'apple', 'phone']

sort my list:
list output: ['apple', 'banana', 'phone']

元组

用括号来定义，用于将多个对象保存到一起。

元组不能被编辑或更改。

相当于不变的列表。

字典

python用的比较多的数据类型。它就像JSON数组。

字典就是一个地址簿，知道姓名就可以找到其地址。分为keys（唯一）与value，一一对应。

data_mail = {
    'chen':'chen@qq.com',
    'lihua':'lihua@163.com',
    'haige':'2016@m.scnu.edu.cn'
}

# 根据key值找value
print("haige's mail is",data_mail['haige'])

# 添加一对键/值
data_mail['xiaoming']='xiaoming@126.com'
if 'xiaoming' in data_mail:
    print('存在xiaoming')

# 删除一对键/值
del data_mail['lihua']
if 'lihua' not in data_mail:
    print('不存在lihua')

# 输出当前的字典总数量
print('numbers:',len(data_mail))

# 输出全部
for name,mail in data_mail.items():
    print('name is {} , mail is {}'.format(name,mail))

输出：
haige's mail is 2016@m.scnu.edu.cn
存在xiaoming
不存在lihua
numbers: 3
name is chen , mail is chen@qq.com
name is haige , mail is 2016@m.scnu.edu.cn
name is xiaoming , mail is xiaoming@126.com

集合

集合是简单对象的无序集合，当集合中的项目存在比次序或出现次数重要时，我们就会用集合。

# 集合
bri= set(['china','USA','UK'])
print(bri)
print('china in bri is','china' in bri)
print('russia in bri is','russia' in bri)

bric = bri.copy()
print(bric)
bric.add('russia')
bric.remove('USA')
print('after doing something...\n',bric)

# 两个集合的并集
print(bri & bric)

结果：
{'china', 'UK', 'USA'}
china in bri is True
russia in bri is False
{'china', 'UK', 'USA'}
after doing something...
 {'china', 'russia', 'UK'}
{'china', 'UK'}

8.序列操作：索引、切片、相加、相乘

索引从0开始：字面量可以直接索引，无需变量赋值。
元素切片,第一个索引包括，第二个索引，不包括
即元素个数为前后相减，3:6，即取3个元素，分别为4,5,6
从头开始[ : num];从尾开始[-num : ]

[:]取整个序列

numbers = [1,2,3,4,5,6,7,8,9,10]
numbers[3:6]
>[4,5,6]
numbers[0:1]
>[0]
numbers[-3:]
>[8,9,10]

步长、隐式、显式

numbers[0:10:2]
>[1, 3, 5, 7, 9]
numbers[::4]
>[1, 5, 9]
numbers[::-2]
>[10, 8, 6, 4, 2]

9.list操作

1.修改-索引赋值
2.删除-del/或者赋值为[]
3.切片赋值-number[2:] = ['a','b','c','d']
4.append-将对象附加到list末尾，对象可以是list或者单一值
5.clear-清空列表内容类似lst[:]=[]，取整个序列赋值为空
6.copy：可以发现，普通操作会同时影响a；需要用到copy方法，

a = [1,2,3,4]
b = a
b[1] = 'k'
>a
[1,'k',3,4]
c = a.copy()
>c[0] = 20
>[20,2,3,4]

7.count-指定元素在list中出现的次数
8.extend-将值附加到list末尾
9.index-指定值第一次出现的索引
10.insert-将一个对象插入列表；插入一个位置，并不会替换掉原值
11.pop-从list中删除一个元素（默认为最后一个）,并返回该元素.栈stack-类似于一叠盘子，上面添加或者上面拿走（后进先出LIFO-last in first out）

a = [1,2,3]
a.pop()
>3
a
>[1,2]

12.remove-删除第一个为指定值的元素；与pop的区别就是不返回值
13.reverse-反转元素（反向排序）,reversed-反向迭代器
14.sort-就地排序，对原list做修改

>x = [2,1,4,9,6]
>y = x.sort()
>print(y)
None
会报错，因为x.sort()是对x进行修改，并不返回值，所以y是None

15.高级排序
sort()可以接受两个参数，key,reverse。其中将key设置为不同的函数是很有用的。

x.sort(key=len)
x.sort(reverse = True)