一.Python基础语法

1基本数据类型

1.1 数值

int 整数
与C、C++、Java不同，Python中整数类型只有一个int，没有短整型short、长整形long。

1.2 浮点数

float 浮点数

1.3 布尔值

bool 布尔值True or Flase
非零即为Ture，零则为False

     In [4]: type(0.3)
     Out[4]: float
     In [5]: type(True)
     Out[5]: bool
     In [6]: type(1)
     Out[6]: int

2 序列类型

2.1 列表

一个有序的队列,可变数据类型;
元素可以是任意对象;
列表内元素有序，可以使用索引;
线性的数据结构;
使用[]表示

列表的定义

list()–new empty list 定义一个空列表
list(iterable)–>new list initialized from iterable

lst1  = list()
lst2 = list(range(10))   
lst = ["2", "3", "a", [1, 2, 3]]

• 列表的访问
  列表索引访问，也叫下标访问
  正索引，从左至右，从0开始
  负索引，从右至坐，从-1开始
  索引不可以超界

In [23]: lst = list(range(10))

In [24]: print(lst)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [25]: lst[0]
Out[25]: 0

In [26]: lst[10]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-26-655442512158> in <module>()
----> 1 lst[10]

IndexError: list index out of range

In [27]: lst[-1]
Out[27]: 9

列表查询

• index(value,[start,[stop]])
  通过值value，从指定区间查找列表内的元素的是否匹配
  匹配第一个就立即返回
  匹配不到，抛出异常ValueError
• count(value)
  返回列表中匹配value的次数
• 时间复杂度
  index和count的方法O(n)
  随着列表数据规模增大而效率下降
• len(list)如果返回列表的个数

列表修改

• append(object)-None
  列表尾部追加元素，返回None
  返回None意味着没有新的列表产生，就地修改
  时间复杂大O(1)
• insert(index,object)-None 尽量少用
  在指定的索引index处插入元素Object
  返回None，不产生新列表，就地修改
  时间复杂度O(1)
  索引能超上下界吗？ 超越上界，尾部追加, 超越下界，头部追加
• extend(iterable)–None
  将可迭代对象的元素追加进来，返回None
  就地修改
• ±->list
  连接操作，将两个列表连起来
  产生新的列表，原列表不变
  本质上调用的是__add__()方法
• *–list
  重复操作，将本列表元素重复n次，返回新列表

列表删除元素

• remove(value)——Nnoe 少做
  从左至右查找第一个匹配的vlaue的值，移除
  就地修改
• pop([inde])–item
  不指定索引，从尾部弹出
• clear()–None 清空所有元素

列表其他操作

• reversed()-None
  将列表元素反转
  就地修改
• sort(key=None,reverse=False)–None
  对列表元素进行排序，就地修改，默认升序
  reverse为True，反转，降序
  key为一个函数，指定key如何排序
• in
  [3,4] in [1,2,[3,4]]
  for i in [1,2,3,4]

列表复制

• copy()->list
  浅复制，shadow copy
• 深拷贝
  copy模块提供了deepcopy

import copy
lst0=[1,[2,3,4],5]
lst1=lst0.deepcopy()

2.2元组

tuple 元组，与列表相似，同样支持下标访问，区别它不可变

命名元组 namedtuple
namedtuple(typename,filed_names,verbose=False,rename=False)
命名元组，返回一个元组的子类
file_names可以是空格或逗号分隔字符

from collections import namedtuple
Student=namedtuple('Stu','name age') //首Student为类名
tom=Student('tom',20)

元组示例

tup1  = ()  # 空元组
tup2 = tuple() # 空元组
tup3 = tuple(range(10))  
print(tup3[0], tup3(1), tup3(-1))
tup3[0] = 27 # 错误，元组不可变

2.3 字符串

一个个字符组成的有序的序列，是字符的结合
使用单引号、双引号、三引号
不可变对象
Python3起，字符串就是Unicode类型
支持使用索引访问
有序的字符集合，字符序列
可迭代

• 字符串join连接

• 字符串分割
  * split() 将字符串按照分隔符分隔成若干字符串，返回列表
  * split() 从左至右分隔
  * rsplit() 从右至左分隔
  * splitlines([keepends])->list of strings
  按照行来切分字符串
  keepends指的是是否保留行分隔符
  行分隔符包括\n,\r\n,\r等
  * partition(sep)–(head,sep,tail) 将字符串按照分隔符分隔成2两部分，返回头、分隔符、尾三部分的元组；如果没有找到分隔符，就返回头、2个空字符的三元组
  sep参数 分割字符串，必须指定
  * rpartition(sep)–(head,sep,tail) 从右至左

• 字符串大小写
  upper()
  lower()
  swapcase() 交互大小写

• 字符串排版
  title()–>每个标题的单词大写
  cacpitalize()
  center(width[,fillchar])
  zfill(width)–>str
  ljust(width[,fillchar])
  rjust(width[,fillchar])

• 字符串替换
  replace(old,new[count])–>str

• 字符串修改*
  strip([chars])–>str
  从两端去掉字符集chars的所有字符
  rstrip([chars])–>str
  lstrip([chars])–>str

• 字符串查找
  find(sub[,start[,end]])–>int
  rfind(sub[,start[,end]])–>int
  index(sub[,start[,end]])–>int
  rindex(sub[,start[,end]])–>int
  注意: find 没有找到，返回-1; index没有找到，抛出异常valueerror

• 字符串判断
  endswitch(suffix[,start[,end]])–>bool
  startswith(prefix[,start[,end]])–>bool
  isalnum()是否是字母和数字
  isalpha()是否是字母
  isdecimal()
  isdigit()
  isidentifier()
  islower()
  isupper()
  isspace()

• 字符串拼接
  join()
  + 拼接字符串

• 字符串格式化
  % 2.5版本之前
  format 2.5版本之后 (推荐使用)

```python
     "{0[0]},{0[1]}".format(('a','b'))
    from collections import namedtuple
    Point=namedtuple('Poinx','x y')
    p=Point(4,5)
    "{{{0.x}}},{{{0.y}}}".format(p)
    # 对齐
    "{0:<2}".format(3)  # 右对齐
    "{0:>2}”.format(3) # 左对齐
    "{0:^2}”.format(3)  # 居中
    "{0:*^20}".format(3)
  # 进制
   "{0:d}".format(3)
   "{0:x}".format(3)
   "{0:o}".format(3)
   "{0:b}".format(3)
   "{0:#d}".format(3)
   "{0:#x}".format(3)
   "{0:#o}".format(3)
   "{0:#b}".format(3)
```

Python3中引入了两个新类型

bytes 不可变的字节序列
bytearray 字节数组、可变

字符串与bytes

        字符串是字符组成的有序序列，字符可以编码
        bytes是字节组成的有序的不可变序列
        bytearray是字节组成的有序的可变序列

编码

• 字符串是按照不同的字符编码encode返回字节序列bytes
  encode(encoding=‘utf-8’,errors=‘strict’)–bytes
• 字节序列按照不同的字符集解码decode返回字符串
  bytes.decode(encoding=‘uft-8’,erros=‘strict’)–str
  bytearray.decode(encoding=‘utf-8’,errors=‘strict’)–str
  bytes() 空bytes
  bytes(int) 指定字节的bytes，被0填充
  bytes(iterable_of_ints)
  bytes(string,encoding[,errors]) 字符串指定编码 等价于string.encoding(),常用这种
  bytes(bytes_or_buffer) 从一个字节序列或者buffer复制出一个新的不可变

bytes对象

• 使用b前缀定义
  只允许基本ASCII使用字符形式b’abc9’
  使用16进制表示b"\x41\x61"

• bytes操作
  * 和String类似，但注意输入的是bytes，输出也是bytes，需要加b前缀
  “b"abcdef”.replace(b’f’,b’k’)
  * 类方法bytes.fromhex(string)
  string必须是2个字符的16进制形式
  * hex()
  返回16进制表示的字符串
  ‘abc’.encode().hex()
  * 索引
  b’abcdef’[2]返回该字节对应的数，int类型

• bytearray定义
  和bytes()类似
  bytearray() 空bytes
  bytearray(int)
  bytearray(iterable_of_ints)
  bytearray(string,encoding[,errors])
  bytearray(bytes_or_buffer)

  因为可变所以比bytes多修改类的操作
  append()
  insert()
  extend()
  pop()
  remove() 找不到抛出异常
  clear()
  reverse()

list、tuple、字符串、bytes、bytearray都是线性的

线性结构:
可迭代
len()
通过下标访问
可以切片操作

2.4 集合

set 可变的,无序的,不重复的元素的集合

set:定义初始化

set中的元素都是不可变的,list\bytearray等可变类型不能作为set的元素.或者不可哈希的,不能作为集合的元素.

set中的元素:

set中的元素要求必须可以hash
不可哈希类型:list\bytearray
元素不可以索引
set可以迭代

set中增加元素

add(elem) 增加一个元素到set中,如果元素存在,什么都不做
update(*others) 合并其他元素到set集合中,参数others必须是可迭代的,就地修改.

set中删除元素

remove(elem) 从set中移除一个元素,元组不存在,抛出keyerror异常.
通过计算哈希值,找到elem,然后移除,而非类似列表中的遍历,效率要高
discard(elem) 从set中移除一个元素,元素不存在,什么都不做
pop()–>item //使用时,不需要参数
移除并返回随机的元素.
空集合返回KeyError异常
clear()
移除所有元素

set修改,查询

修改 要么删除,要么加入新的元素,没有直接修改的操作
查询 非线性结构,无法索引
遍历 可迭代
成员运算符 in和not in 判断元素是否存在.效率很高

set和线性结构

线性 线性结构的查询时间复杂度O(n)，随着数据规模的增大，耗时越来越长
set、dict等结构，内部使用哈希值作为key，时间复杂度可以做到O(1)，查询时间和数据规模无关。

可哈希类型

数值型 int、float、complex等
bool类型
字符串类型string、bytes
tuple
None
以上都是不可变类型，成为可哈希类型

集合运算

• 并集：
  union(*others)：返回和多个集合合并后的新集合
  | 运算符重载，等同于union
  update(*others) 和多个集合合并，就地修改
  |= 等同于update 中间不可以有空格

• 交集:
  intersection(*others) 返回和多个集合的交集
  等同于 &
  intersection_update(*others)
  获取多个集合的交集，并就地修改
  &= 等同于intersection_update

• 差集：
  difference(*others)
  等同于 - 返回多个集合的差集
  differnece_update(*others) 获取和多个集合的差集就地修改
  -= 等同于difference_update

• 对称差集
  集合A和B，由所有不属于A和B的交集元素组成的集合，记作(A-B) U (B-A)
  symmetric_difference(other)
  返回和另一个集合的对称差集
  等同于^
  symmetric_difference_update()
  获取和另一个集合的差集，就地修改
  等同于^=

• issubset(other)、 <= 判断当前集合是否是另一个集合的子集
  set1 < set2
  判断set1是否是set2的真子集
  issuperset(other) >=
  判断当前集合是否是other的超集
  set1 > set2
  判断set1是否是set2的真超集
  isdisjoint(other)
  当前集合和另一个集合没有交接，没有交接返回True

2.5 字典

• 字典dict

key-value键值对的数据的集合
可变的、无序的、key不可重复

• 字典的定义 初始化：

d = dict() 或者 d = {}
ditc(**kwargs) 使用name=value对初始化一个字典
dict(a=‘zhangsan’,b=‘lisi’)
dict(iterable,**kwarg)使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构。
dict(((1,‘a’),(2,‘b’)))
dict(mapping,**kwarg) 使用一个字典构建另一个字典
类方法：
d = dict.fromkeys(range(5))
d = dict.fromkeys(range(5), 0)

• 字典元素访问
  d[key]
  返回key对应的值，key不存在抛出异常
  get[key[,default]]
  返回key对应的值，key不存在返回缺省值，没有缺省值返回None
  setdefault(key[,default])
  返回key对应的值，key不存在，则添加key-value。

• 字典增加和修改

d[key]=value
将key对应的值改为vlaue，如果key不存在，则添加
update([other])–>None
使用另一个字典的kv更新本字典
key不存在，则添加
可存在，覆盖已存在的key对应的值
就地修改
d.update(red=1)
d.update(((‘red’,2),))
d.update({‘red’:3})

• 字典删除
  pop(key[,default])
  key存在，移除它，返回它的value
  key不存在，返回给定的default
  未设置default，key不存在则抛出异常
  popitem()
  移除并返回一个任意的键值对
  字典为empty，抛出keyError异常
  clear()
  清空字典
  del语句:del 本质上是减少了一个对象的引用，del实际上删除的是名称，而不是对象

• 字典遍历

for ... in dict
    遍历key
        for k in d:
            print(k)
        for k in d.keys():
            print(k)
    遍历value
        for k in d:
            print(d[k])
        for k in d.keys():
            print(d.get(k))
    遍历item
        for item in d.items():
            print(item)
        for k,v in d.items():
            print(k,v)

• 总结：
  Python3中，keys，values，items方法返回一个类似生成器的可迭代对象，不会把函数的结果复制到内存中。
  Python2中，上面的方法会返回一个新的列表，占据新的内存空间，所以python2建议使用iterkeys、itervalues、iteritems版本，
  返回一个迭代器，而不是一个copy。
  字典的key
  key的要求和set元素要求一致

defaultdict

collections.defaultdict(default_factory[,…])
第一个参数是default_factory,缺省是None。它提供了一个初始化函数，当key不存在的时候，会调用这个初始化函数，生成key对应的value。

    from collections import defaultdict
    d1 = {}
    d2 = default(list)
    for k in "abcde":
        for v in range(5):
            if k not in d1.keys():
                d1[k]=[]
            d1[key].append(v)
    print(d1)
    for k in 'mnopq':
        for v in range(3):
            d2[k].append(v)
    print(d2)

OrederedDict 解决3.5版本及之前版本字典key无序的问题

collections.OrderedDict(itmes)
key并不是按照加入的顺序排列，可以使用OrderedtDict记录顺序

    from collections import OrderedDict
    import random
    d = {'banana':3, 'apple':4, 'pear':1, 'Orange':2}
    print(d)
    keys=list(d.keys())
    random.shuffle(keys)
    print(keys)
    od = OrderedDict()
    for key in keys:
        od[key] = d[key]
    print(od)
    print(od.keys())

3.6版本字典dict中记录了字典中元素的加入顺序

3. 运算符

3.1 算数运算符

• 算数运算符如下

运算符	描述	实例
+	加	10 + 30
-	减	5 - 3
*	乘	30 * 20
/	除	10 / 20
//	取整除	返回除法的整数部分（商），如 7 // 2 输出结果 3
%	取余数	返回除法的余数 7 % 2 = 1
**	幂	又称次方、乘方，2 ** 3 = 8

• 算数运算符的优先级

和数学中的运算符的优先级一致，在 Python 中进行数学计算时，同样也是：
* 先乘除后加减
* 同级运算符是 从左至右 计算
* 可以使用 () 调整计算的优先级

• 以下表格的算数优先级由高到最低顺序排列

运算符	描述
**	幂 (最高优先级)
* / % //	乘、除、取余数、取整除
+ -	加法、减法

3.2.位运算符

运算符	描述
&	位与
|	位或
~	取反
^	异或
<<	左边移位
>>	右边移位

2.3 比较运算符

运算符	描述
>	大于
>=	大于等于
<	小于
<=	小于等于
==	等于
!= 、<>	不等于

3.4 赋值运算符

运算符	描述
+=	a+=1 等价于 a=a+1
-=	类似
*=	…
**=	…
/=	…
%=	…

3.5逻辑运算符

运算符	描述
and	逻辑"与"，两边为真返回布尔值’True’，否则返回False
or	逻辑"或"，两边为假返回布尔值’Flase’，否则返回True
not	逻辑"非"

3.6 成员运算符

运算符	描述
in	如果在指定的序列中返回True，否则返回Flase
not in	若不在指定的序列中返回True，否则返回False

4. 变量

4.1 变量定义

• 在 Python 中，每个变量 在使用前都必须赋值，变量 赋值以后 该变量 才会被创建

变量名 = 值

示例

# 定义 class_num 的变量用来保存班级序号
In [8]: class_num = '01'
In [9]: print(class_num)
01

4.2 变量的类型

• 在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）

• 数据类型可以分为 数值型 和 非数值型

• 数字型

  • 整型 (int)
  • 浮点型（float）
  • 布尔型（bool）
    • 真 True ---- 非零即真
    • 假 False ----0
  • 复数型 (complex)
    • 主要用于科学计算

• 非数值类型

  • 字符串
  • 列表
  • 元组
  • 字典

• 使用 type() 函数可以查看一个变量的类型

4.3 不同类型变量之间的计算

1) 数值类型变量之间可以直接计算

• 在 Python 中，两个数值类型变量是可以直接进行 算数运算的
• 如果变量是 bool 型，在计算时
  • True 对应的数字是 1
  • False 对应的数字是 0

2) 字符串变量 之间使用 + 号，则是进行字符串的拼接

In [10]: str1 = "My name is"

In [11]: str2 = "张三"

In [12]: str1 + str2
Out[12]: 'My name is张三'

3) 数值类型变量 和 字符串 之间 不能进行其他计算

In [16]: str1 = "She is"

In [17]: age = 18

In [18]: str1 + age
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-18-0a392e70e75a> in <module>()
----> 1 str1 + age

TypeError: can only concatenate str (not "int") to str

4.4 变量的输入 input

• 在 Python 中，如果要获取用户在 键盘 上的输入信息，需要使用到 input 函数

函数: 封装好的代码块，可以进行复用(别人或者自己写的代码)，可以直接使用，而 不用关心内部的细节

函数	说明
print(x)	将 x 输出到控制台
type(x)	查看 x 的变量类型
input	获取键盘输入

示例:

In [19]: info = input("输入信息")
输入信息12345

In [20]: info
Out[20]: '12345'

变量类型转换

函数	说明
int(x)	将 x 转换为一个整数
float(x)	将 x 转换到一个浮点数

5 程序控制

高级语言中，程序控制无非是顺序、分支、循环

5.1顺序

按照先后顺序一条条执行
示例代码

""" 
先定义变量 a、b，再定义变量c，最后打印c的值
"""
a = 1
b = 2
c = a + b
print(c)

5.2 分支

Python的分支语句就是if，满足条件则执行，不满足则转到下一个分支条件

a = 1
b = 2
max_num = None
if a > b:
    print(a)
elif a<b:
    print(b)
else:
    print("a = b")

5.2 循环语句

• whlie循环

a = 1
sum = 0
max_num = 9
while a < max_num:
       sum + = a
       a += 1
print(sum)

• for 循环
  常用语遍历
  示例代码打印 九九乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print(str(i)+"*"+str(j)+"="+str(i*j),end=" ")
    print("\n")