1、基础知识
【数据类型】
整数
浮点数(一个浮点数的小数点的位置是可变的) 1.23e9 1.2e-5
字符串(是以单引号和双引号括起来的任意文本)
''和“”只是一种表达方式并不是字符串的一部分,如果需要字符串中含有‘和“的字符,则需要用到的是”“
或者直接是转义字符
>>> print('\\\n\\')
\
\
为了简化,允许使用r' '来表示内容的字符串默认不转义
用\n写在一行里来表示换行不好阅读,可以使用’‘’...‘’‘来表示多行内容
布尔值(ttue 和 false)
布尔值可以用and or 和not 运算
not true 为0
空值是Python里一个特殊的值,用None
表示。None
不能理解为0
,因为0
是有意义的,而None
是一个特殊的空值
变量的定义:变量在程序中就是用一个变量名表示了,变量名必须是大小写英文、数字和_
的组合,且不能用数字开头
变量本身类型不固定的语言称之为动态语言,与之对应的是静态语言
常量
所谓常量就是不能变的变量,比如常用的数学常数π就是一个常量。在Python中,通常用全部大写的变量名表示常量:
PI = 3.14159265359
但事实上PI
仍然是一个变量,Python根本没有任何机制保证PI
不会被改变,所以,用全部大写的变量名表示常量只是一个习惯上的用法,如果你一定要改变变量PI
的值,也没人能拦住你。
(因此这里所谓的常量只是使用者的约定而已,没有机制保证该量不被改变)
Python中的两种除法
/
除法计算结果是浮点数,即使是两个整数恰好整除,结果也是浮点数
还有一种除法是//
,称为地板除,两个整数的除法仍然是整数:
>>> 10 // 3
3
因为//
除法只取结果的整数部分,所以Python还提供一个余数运算,可以得到两个整数相除的余数:
>>> 10 % 3
1
内置数据类型list [ ]
(有序的集合,可以随时添加和删除其中的元素)
用函数len可以获得list元素的个数
用索引来获得其中每一个的元素,按照从前往后的索引0开始,按照从后往前的索引最后的元素的索引号为-1
1、添加元素(直接从最后面开始加) 指定位置添加元素 append insert(位置,元素)
2、删除元素(删除末尾元素) 删除指定位置的元素 pop(i)
3、替换元素
list里面的元素的数据类型也可以不同,比如
>>> L = ['Apple', 123, True]
list元素也可以是另一个list,比如:
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4
要注意s
只有4个元素,其中s[2]
又是一个list,如果拆开写就更容易理解了
>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
要拿到'php'
可以写p[1]
或者s[2][1]
,因此s
可以看成是一个二维数组
常用的函数:
len(list) | |
max(list) | |
min(list) | |
list(seq) | |
list.append(obj) | |
list.insert(index, obj) | |
list.pop(index=-1) | |
list.remove(obj) | |
list.reverse() | 在原来list基础上反转 |
list.sort(key=None, reverse=False) | |
list.clear() | 清空列表 |
list.copy() | 复制列表 |
list.extend(seq) | 一次性在源list基础上添加多个值 |
list.index(obj) | |
list.count(obj) | |
- list.sort(key, reverse)会直接改变原来的list,若是不想改变可以选用sorted函数sorted和sort函数的区别
- key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则,reverse = True 降序, reverse = False 升序(默认)
L=[('b',2),('a',1),('c',3),('d',4)]
sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
sorted(L, key=lambda x:x[1]) # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
内置数据类型元组tuple ( )
(有序列表,一旦初始化不能修改,内容不可变,代码会更加安全)
>>> classmates = ('Michael', 'Bob', 'Tracy')
但是,要定义一个只有1个元素的tuple,如果你这么定义:
>>> t = (1)
>>> t
1
定义的不是tuple,是1
这个数!这是因为括号()
既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1
。
所以,只有1个元素的tuple定义时必须加一个逗号,
,来消除歧义:
>>> t = (1,)
>>> t
(1,)
定义“可变的”tuple
tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。
即指向'a'
,就不能改成指向'b'
,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!
内置字典类型dict { }
(按照键——值存储)具有较高的查找速度————这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能根据key直接拿到value。
根据key值来保存相应的value值,故只需要找到key值就可以找到value值,相比于之前的用两个tuple来分别存储相应的key和value而言,速度上确实会提高不少。
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
1、添加数据(可以在初始化的时候添加,也可以通过key的方式添加)
d['jack']=23
2、判断对应的key是否存在
>>> 'Thomas' in d
False
二是通过dict提供的get()
方法,如果key不存在,可以返回None
,或者自己指定的value:
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1
3、删除一个key
用pop(key)
方法,对应的value也会从dict中删除
dict的key必须是不可变对象, 在Python中,字符串、整数等都是不可变的
常用的函数
dict.popitem() | 随机返回并删除字典中的最后一对键和值。 |
dict.pop(key) | |
dict.values() | 返回迭代器 |
dict.keys() | 返回迭代器 |
dict.items() | 返回可遍历的(键, 值) 元组数组,外部list,内部tuple元素 |
key in dict | 判断key是否在dict中 |
dict.get(key) | |
dict.clear() | 删除字典中所有元素 |
dict.copy() | 返回字典的浅拷贝 |
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值,传对象的引用
c = copy.copy(a) #对象拷贝,浅拷贝
d = copy.deepcopy(a) #对象拷贝,深拷贝
内置数据类型set { }
(于dict类似,是一组key的集合,但是不存储value,且key不重复)
set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作
初始化用list来作为输入
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
1、添加元素add(key)
2、删除元素remove(key)
不可变对象
2、函数和模块部分
内置模块
第三方模块
自编模块
模块本身就是一个Python的文件,内部里面封装了各种函数而已,可以将其封装成私有的函数和变量
$ python3 hello.py
Hello, world!
$ python hello.py Michael
Hello, Michael!
import hello (导入模块文件)
hello.test( ) (使用模块文件中的函数)
特殊变量和私有变量
__XX__ 和 _XX或者__XX
安装库和库路径的修改和搜索
2、设置环境变量PYTHONPATH
返回函数
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
并不直接求出结果,而是可以通过后续的判断,再一步函数计算
3、类编程操作
变量和函数
数据的封装
函数定义的第一个参数为self,且在调用的时候,除了self以外的参数均需要传入
4、补充说明
【python的运算符】
算术运算符:+ - * / % ** //
比较(关系)运算符:== != >= <= > <
赋值运算符: += -= *= /= %= **= //=
逻辑运算符: and or not(非)
位运算符: & | ^ ~ (按位计算) << >>
成员运算符:in not in
身份运算符: is is not(身份id的标识符是不是引自同一个对象)
4大常用高级函数的解析
map,返回的是迭代器,用list函数转化为列表
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
reduce,把一个函数作用在一个序列[x1, x2, x3, ...]
上,这个函数必须接收两个参数,reduce
把结果继续和序列的下一个元素做累积计算
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
def fn(x, y):
... return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579
filter,filter()
把传入的函数依次作用于每个元素,然后根据返回值是True
还是False
决定保留还是丢弃该元素
def not_empty(s):
return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
# 结果: ['A', 'B', 'C']
sorted,可以排序任何迭代对象,不限制于list中,默认reverse是false,代表升序排列,true是降序排列
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']