Python基础专题

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()	返回字典的浅拷贝

 Python 直接赋值、浅拷贝和深度拷贝解析

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']