Python基础

python解释器：用来执行.py文件

    CPython：官方的

    IPython：基于CPython的交互式解释器

    PyPy：采用JIT技术，对Python代码进行动态编译，显著提升代码的执行速度

    Jython：Java平台上的Python解释器，可以直接把Python代码编译成java字节执行

    IronPython：运行在.Net平台上的Pythone解释器，把代码翻译成.Net字节码

 

在mac和linux上直接执行.py文件，只需要在第一行添加：

     #!/usr/bin/env python3
    print('hello, world')

输入和输出：

     print('hello world')
     name=input('input your name: ')
     print('hello', name)
     input()返回的数据类型是str

格式：Python采用缩进来组织代码块，大小写敏感，坚持使用4个空格的缩进

 

数据类型：

     整数：整数运算永远是精确的 地板除// 求余数% 没有大小限制

     浮点数：没有大小限制 超出一定范围直接表示为inf（无限大）

     字符串：单引号 双引号 转义字符 r默认不转义 '''...'''表示多行内容

         int(str)：将str转为int

         ord()：字符->整数编码

         chr()：整数编码->字符

         前缀b：对应的bytes

         encode()：str转为指定编码格式的bytes

         decode()：bytes转为str，网络或磁盘上读取的bytes，通过此方法转为str，可以使用参数errors='ignore'来忽略无法转换的部分

         len()：str的字符数，或bytes的字节数

         格式化字符串：

             和c一样的占位符规则，%s % %f %x，整数和浮点数可以手动指定位数，%%表示%

             format()：使用{x}占位符，和c#有点类似

     bool： True False and or not

     空值：None

     变量：动态语言，类型不固定（静态语言：变量类型固定的语言）

     常量：约定全部大写的变量表示常量

 

字符编码：

    ASCII：一个字节表示，127个字符

    GB2312：中文编码，而且不和ASCII冲突

    Unicode：把所有语言统一到一套编码里，通常2字节，特殊多个字节

    UTF-8：可变长编码，将Unicode编码成1-6个字节，以节省空间

    内存：统一使用Unicode编码

    存储或传输：UTF-8编码

    Python3中，字符串是以Unicode编码的，如果需要网络传输或保存磁盘，需要手动转为字节bytes

    坚持使用UTF-8对str和bytes进行转换

    Python源文件保存为UTF-8格式，Encoding in UTF-8 without BOM

    为了让python解释器按照UTF-8读取，通常在文件开头处添加：   

     #!/usr/bin/env python3
     # -*- coding: utf-8 -*-

         第一行：告诉Linux/OS Xx系统，这是一个Python可执行文件

         第二行：告诉解释器使用UTF-8编码格式读取

    

使用list和tuple:

    list：有序列表 []

         len(lst)：获取元素个数

         append(arg)：末尾追加元素

         insert(i, arg)；位置i插入元素

         pop()：删除末尾元素

         pop(i)：删除第i个元素

    tuple：有序列表()，初始化后不可修改

         只有一个元素的tuple：(1,)

         使用：因为不可变，所以更安全，在没有修改需求时尽量使用tuple

          a = 1, 2, 3    // tuple，括号可以省略

 

dict和set：

    dict：字典，查找速度快，key必须是不可变对象，比如int，str

 dic = {'a':1, 'b':2, 'c':3}
 访问：
     print(dic['a'])          []访问key不存在会报错
     dic['a'] = 5
     exist = 'a' in dic
     dic.get('a')     值不存在返回None
     dic.get('a', -1) //-1表示缺省值
 删除：
      pop(key)

    set：不重复集合，原理和dict一样，但不存储value，也要求存放不可变对象

add(key)：添加已有元素无效
remove(key)       

 

条件判断：计算机之所以能做很多自动化的任务，因为它可以自己做条件判断

if cond1:
      do1
elif cond2:
      do2
elif cond3:
      do3
else:
      do4

 

循环：让计算机能够做重复运算

    for循环：

 遍历list或tuple:
       for name in names:
           print(name)
 遍历dict:
      for key in d:
           print(key)
      for value in d.values():
           print(value)
      for k,v in d.items()
           print("key {} value {}".format(k, v))
           print(k, v)

    range(n)：生成0到n的整数序列

         list(range(n))

    while循环：

         while cond:

              do

          break

          continue

    

函数：是一种最基本的代码抽象

    数据类型转换：

          int() float() str() bool() hex()

    函数别名：函数名其实就是指向一个函数对象的引用

    函数定义：

         def func(args):

              ...

    导入别的python文件中的函数：

　　  from filename import functionName 

    空函数：用来表示函数占位符，pass表示什么也不做

         def func():

              pass

    参数检查：isinstance

        if not isinstance(x, (int, float)):
            raise TypeError('bad operand type') 

    多返回值函数：其实是返回一个tuple

    参数：

         位置参数：普通必传参数

         默认参数：必须指向不变对象

         可变参数：传入0个或任意个参数，自动组装成一个tuple

             def func(*args):

                  ...

             定义的时候，参数前面加*

             函数调用时，在list或dict前面加个*可以自动转为可变参数传进去

         关键字参数：传入0个或任意个参数，自动组装成一个dict

               def func(**kw):

                   ...

              定义的时候，参数前面加**

              函数调用时，在dict前面加**可以自动生成dict的拷贝传进函数，而且不会影响原有的dict

          命名关键字参数：

              def func(arg1, arg2, *, namedArg1, namedArg2)

                   namedArg1和namedArg2需要带着参数名和值传递

              def func(arg1, arg2, *args, namedArg1, namedArg2)

                  如果前面有一个可变参数，则可省略前面的*

              可以提供默认参数值

         参数组合顺序：必选参数 默认参数 可变参数 命名关键字参数 关键字参数

 

递归函数：

    放置递归调用太深导致栈溢出，因为每次函数调用都会增加一层栈溢，返回时减少，但栈的大小是有限的。

    尾递归：return时只调用函数本身，没有其他任何计算

    python的标准解释器没有针对尾递归做优化，所以还是会栈溢出

    

高级特性：

    切片：相当于字符串截取函数

         L[0:3] 取0-3（不包括3）的元素

         L[:10:2] 前10个每2个取一个

         L[::5] 所有元素每5个取一个

         L[:] 直接复制一个list

         tuple切片的结果仍是tuple

         str切片的结果仍是str

         有了切片操作，很多地方的循环就不再需要了

    迭代：任何可迭代对象都可以用作for循环，包括自定义数据类型

         判断一个对象是否是可迭代的：

from collections import Iterable
print(isinstance('abc', Iterable))

    列表生成式：可以快速生成list，可以通过一个list推导出另一个list，代码十分的简洁

list[range(1, 11)]
[x * x for x in range(1, 11)]
[x * x for x in range(1, 11) if x % 2 == 0]
import os
[d for d in os.listdir('.')]
[k + '=' + v for k,v in dict.items()]
[s.lower() for s in lst]

    生成器：generator

         定义：把列表生成式的[]换成()即可

         含义：generator存储的是算法，调用next(g)会动态计算出下一个元素

         用法：使用for循环访问，一般不使用next(g)函数

         yield：如果一个函数定义包含yield关键字，则这个函数就是一个generator

         普通函数返回结果，generator函数，返回的是一个generator对象

 def odd():
    print("first")
    yield 1
    print("second")
    yield 3
    print("third")
    yield 5

     迭代器：Iterable和Iterator

         Iterable：可迭代对象，就是能被for循环的数据类型：

              （1）集合数据类型，list tuple dict set str

              （2）generator，包括生成器和带yield的generator function

         Iterator：可以被next()函数调用并不断返回下一个值的对象

              Iterator是一个惰性计算的序列，可以表示无限大的序列

              集合类型可以通过iter()函数转化为Iterator对象

 L = [1, 2, 3]

 for v in L:
 print(v)

 it = iter(L)
 while True:
    try:
        print(next(it))
    except StopIteration:
        break

  

函数式编程：

    

 

 删除目录：

import os
import shutil

os.remove(path)   #删除文件
os.removedirs(path)   #删除空文件夹

shutil.rmtree(path)    #递归删除文件夹

 

pip：

pip install xxx：
　　安装xxx
　　再次数据上述命令，可以查看安装目录
pip freeze：
　　已经装了哪些库
python -m pip install --upgrade pip
　　pip升级