基础
运算符
//表示整除
%求余数
**乘方
语句和表达式
表达式是一些东西，语句是做一些东西
比如
2*2
print(2*2)
floor向上取整
ceil向下取整
用变量来引用函数
foo = math.sqrt
foo(4)=2.0
运行py文件的方法
1.python+_.py(文件路径要给出)
2.或者在py文件头加#!/usr/bin/env python，
然后chmod a+x _py，也要加路径，运行完后，可直接将文件拖入终端即可运行。
字符串
repr将对象转化为解释器能读取的形式
str则是将对象转化为人读取的形式
长字符串```
原始字符串r,结果不会处理中间的/;
但是不能以/结尾，需要对/进行转义，
print(r'c:/book/我是书.txt')
#/结尾出错，需要对/单独转义
raw---print(r'c:/book/this/')
out---print(r'c:/book/this' '//')
unicode,bytes,bytearray
二进制(0，1)表示，每8个一组，为1字节,1字节只能表示256个不同的值，其中bytes只能表示128个值
以后再补
列表和元组
序列--包括
容器：可包含其他对象的对象--主要包括：序列(列表，元组)，映射(字典)，集合(set)
列表(可修改)
元组(不可修改)
容器container
序列
list
tuple
映射
dict
集合
set
序列操作--索引，切片，相加，相乘。。。
索引从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]
序列相加，相乘
None,空列表[],初始化
判断--布尔值用in来判断
相关函数-len(),max(),min()
list操作
字符串变列表
list('hello')
>['h','e','l','l','o']
' '.join(some_list)
>'book'
修改-索引赋值
删除-del/或者赋值为[]
切片赋值-number[2:] = ['a','b','c','d']
list方法--就是对象的函数
object.method(arguments)调用
1.append-将对象附加到list末尾，对象可以是list或者单一值
2.clear-清空列表内容类似lst[:]=[]，取整个序列赋值为空
3.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]
4.count-指定元素在list中出现的次数
5.extend-将值附加到list末尾
6.index-指定值第一次出现的索引
7.insert-将一个对象插入列表；插入一个位置，并不会替换掉原值
8.pop-从list中删除一个元素(默认为最后一个),并返回该元素
栈stack-类似于一叠盘子，上面添加或者上面拿走(后进先出LIFO-last in first out)
a = [1,2,3]
a.pop()
>3
a
>[1,2]
9.remove-删除第一个为指定值的元素；与pop的区别就是不返回值
10.reverse-反转元素(反向排序),reversed-反向迭代器
11.sort-就地排序，对原list做修改
>x = [2,1,4,9,6]
>y = x.sort()
>print(y)
None
会报错，因为x.sort()是对x进行修改，并不返回值，所以y是None
需要用到copy()方法/或者sorted()函数,返回一个列表；
那么方法和函数的区别是什么呢？function/ method?
12.高级排序
sort()可以接受两个参数，key,reverse。其中将key设置为不同的函数是很有用的。
x.sort(key=len)
x.sort(reverse = True)
元组tuple--也是序列，但不能修改
创建
1.直接输入
2.用()
3.()表示空元组
4.只表示一个值
>43,
>(43,)
tuple to list
```
tuple(lst)
```
作用
作为映射中的键
某些内置函数和方法需要返回元组
字符串
设置字符串格式
%
format字符串方法，替换{},每个替换字段用{}。
>"{2}{3},{0} {0} {1}-{3}".format("to","be","or","not")
>'ornot,to to be-not'
字符串方法
1.center-在两端填充字符，使字符串居中
x.center(num,"strings")
2.find-查找子串，找到返回第一个字符的索引，找不到返回-1;可以用来查看是否存在某些元素
>k = "what is the weather today?".center(40,"~")
'~~~~~~~what is the weather today?~~~~~~~'
>k.find('book')
-1
>k.find('is')
12
>k.find('t',12,200)#设置起点和终点，包含起点，不包含终点
15
3.join-用法" ".join(lst),其中元素必须是字符串
4.lower-返回小写字符串，strings.lower();首字母大写strings.title()
5.replace-替换并返回替换后的结果
6.split-与join相反,拆分为序列
7.strip-删除字符串头尾的空白，并返回结果如果strings.strip('*~')删除首尾某些符号
8.translate-同replace,需要一个替换表
9.is开头
字典--映射的数据结构
序列是通过编号来访问值，字典是通过名称来访问
创建字典
键-值
项item：键-值对
{key1:value1,key2:value2....},其中key是唯一的,且不可改变，key可以是字符串，数字，元组
1.dict函数
>tems = [('name','kobe'),('age',37)]
>d = dict(items)
{'name': 'kobe', 'age': 37}
#或者如下：
>d = dict(name = 'kobe',age=37)
字典方法
1.clear-删除字典所有项，返回None
2.copy-浅复制，替换原件不影响，修改则受影响。这时需要用到copy模块 deepcopy()函数
浅copy和赋值都属于引用对象，深copy则为两个独立对象。
3.fromkeys-创建新字典，包含键，值为None
dict.fromkeys([key1,key2...])
4.get-可以用于访问不存在的key，返回None，或者自设的返回值
d.get(key,strings)-eg.d.get('name','N/A')
5.items-返回list，包含(key,value)
6.keys-返回key的视图
7.pop-删除键-值对
8.popitem-随机删除一项
9.setdefault-类似于get(),没有就往里面加
10.update-更新字典，key相同则替换，不同则往里添加。
条件、循环、其他语句
1.赋值-序列解包(可迭代对象解包)
左右元素必须相等，用*rest可以装剩下的元素,返回list
>x,y,z = 1,2,3
>values = 1,2,3
(1,2,3)
>x,y,z = values
>a,b,*rest = [1,2,3,4,5,6]
>rest
[3,4,5,6]
赋值语句右边是任何序列，*是一个list
2.链式赋值
x = y = somefun()等价于
x = y和y = somefun()
增强赋值
x + = 1,累计运算
2.条件语句
if _pass_ :
else:
或者
if _pass_:
elif :
else :
比较运算符
is-同一个对象,x与z虽然相等，但不是同一个对象；
list相等不等于相同，==来检查是否相等，is来看是否属于同一个对象,因为不同的对象可以进过变换成相等的，但本质仍为不同对象。
x = y = [1,2,3]
z = [1,2,3]
>x is y
True
>x == z
True
字符串比较
其实是比较字符的顺序值
and,or,not布尔运算符
用assert来判断是否正确
3.迭代
并行迭代
>names = ['a','b','c','d','e']
>ages = [1,2,3,4,5]
>zip(names,ages)#可迭代对象
>list(zip(names,ages))
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
迭代获得索引
enumerate()-可迭代对象，索引-值的元组对
向后迭代和排序后迭代--大小写敏感
sorted()返回一个升序排序后的list
reversed()返回一个逆向排序的迭代器
跳出循环
break-满足条件跳出循环
continue-
while True-
循环中的else语句
推导
列表表达式
匹配男女同首字母对人
>girls = ['alice','bernice','clarice']
>boys = ['chris','arnold','bob']
lg = {}
for g in girls:
#g-girl_name;g[0]-first_letter,创建首字母字典，key-letter,value-[],返回一个空list，对其进行append方法
lg.setdefault(g[0],[]).append(g)
print([B+'+'+G for B in boys for G in lg[B[0]] ])
#字典推导
>{i:"{} squared is {}".format(i,i**2) for i in range(10)}
{0: '0 squared is 0',
1: '1 squared is 1',
2: '2 squared is 4',
3: '3 squared is 9',
4: '4 squared is 16',
5: '5 squared is 25',
6: '6 squared is 36',
7: '7 squared is 49',
8: '8 squared is 64',
9: '9 squared is 81'}
(),{}分别是生成器和字典推导
4.pass,del,exec
pass-什么都不做
del
exce-将字符串作为代码执行,不返回任何值
>exec("print('hello world!')")
hello world!
>eval("input('enter your name: ')")
'tony'
eval-返回,计算用字符串表示的python表达式的值
抽象
使用的函数命名应该通俗，一看就知道是做什么的。
函数编写文件-定义函数以后在del后加'strings',代表函数的说明,用func.__doc__查看函数说明。
所有函数都有返回值，没给的话默认是None
def test():
print('this is printed')
return
print('this is not')
>x = test()
this is printed
>print(x)
None
1.参数
行参-函数名后面的变量
实参-调用函数提供的值
def try_to_change(n):
n = 'mr.gumby'
name = 'mr.entity'
>try_to_change(name)
>name
'mr.entity'
从该例子可以看出，函数内行参：n,而运行的时候其实就是将name传递给n，对变量name本身并没有影响。参数存储在局部作用域。，如果参数是列表等，则需要用到list方法.copy()
lst[:]得到的是副本。
关键字参数
可以设置关键字参数，或者定义函数时设置成默认值
#也可以给默认值
#def hello_2(name = '',greeting ='')
def hello_2(name,greeting):
print('{},{}!'.format(name,greeting))
>hello_2(greeting='how are you',name='tony')
tony,how are you!
收集参数
def func(*params):定义参数时，参数前面加*表示将所有值放入一个元组中，*不收集关键字参数
用**可以收集关键字参数，返回字典
def print_params_4(x,y,z=3,*pospar,**keypar):
print(x,y,z)
print(pospar)
print(keypar)
>print_params_4(1,2,3,4,5,6,7,foo= 1,bar = 2)
1 2 3
(4, 5, 6, 7)
{'foo': 1, 'bar': 2}
分配参数
调用函数的时候，func(*params)，将参数值分配给定义的函数，**是分配字典，*分配(序列)元组或者列表。
作用域
变量类似于看不见的字典,这种看不见的字典就是命名空间或者作用域
局部变量和全局变量
globals-返回包含全局变量的字典
local-包含局部变量的字典
如果参数重名，则globals()['重名参数']
重新关联-在内部重新定义全局变量global+变量名
作用域嵌套/闭包,更好的理解,调用和引用(在内存中存储了地址)。
递归
抽象2
对象：
多态
不同类型的对象执行相同的操作
封装
对外部隐藏对象工作原理的细节
继承
类
异常
raise
try:
x = int(input('enter the first number: '))
y = int(input('enter the second number: '))
print(x/y)
except ZeroDivisionError:
print("The second number can't be zero!")
用 try/except xxError来捕获异常
特性和迭代器
模块
592
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
