Python笔记(一)

##第一章
1-1 Python开发环境
小要求：最好能够熟悉Linux基本操作，Linux是程序员的必备开发使用系统。

基于windows操作系统，安装开发环境。（不会的话可以上B站搜索相应的安装视频）
    Python官方网址（www.python.org）
    接着寻找相应的操作系统的Python版本。
    在选择的时候尽量把两个条件都选择上，减少你后期配置Path的环境变量的时间

    如果你想要集成开发环境，可以下载一个Pycharm
    官网下载地址：https://www.jetbrains.com/pycharm/download/
    安装地址：
    http://www.runoob.com/w3cnote/pycharm-windows-install.html
    具体的配置可以去B站搜搜看，这里我提供一个地址（也许会失效）：
    https://www.bilibili.com/video/BV17b411e7M9?from=search&seid=4945926071261645762

    Eclips也可以配置Python环境，然后创建文件就可以了。奇猫的第一个视频会有详细步骤，如果遇到乱码，
    那么就是编码集出了问题。你需要调整一下你的编码集

1-2 变量与解释器内存管理

变量：
例如：a = 1   地址:0x1122  b = 2 地址：0x3344
     改 a 的值 a = 2 地址 0x3344  
     此时 a 和 b 的地址都是一样的，都是0x3344

解释器内存管理机制:

 先取一定数量的大小为256Kb的arenas空间，然后以链表的形式记录里面用过的空间。
 每一个arenas也是以链表的方式进行连接，每一个arenas中用过的数据都是以链表的方式连接，没用过的内容也是以链表方式连接。
 当你调用值时，那么先从已经记录过的地址去寻找，如果没有就新开辟一个地址。python解释器的垃圾回收机制是不会把你这个内存释放的，
 使用申请到一定量就不能申请了，只能从空闲的地址或arenas里面调用了。

1-3 python的基本语法
连接符”反斜杠”：
连接多个物理行，例如：
display = “ This is test func反斜杠
This is test func反斜杠
This is test func”

 引号：
     单引号、双引号、三引号标识字符：
     str = 'HelloWord'
     str = "HelloWord"
     str = """HelloWord"""
     str = '''HelloWord'''

注意事项：
    在输出字符串常量直接引用单引号(')和双引号(")的时候
        使用"的时候。字符串定义不难以"开始和结束
        使用'也是同样的道理

##第二章 Python的数据结构
2-1 数据结构——数字
数字的类型： int —> 整型 24字节
long —> 长整型(也许已经和int合并在一起了) 28字节
longa = 10L
float —> 浮点数 24字节
complex —> 复数 32字节
complexa = 4 + 1j
boolean —> 布尔值 24字节

        Python解释器对int、float、有最大限制，
        在赋值的时候python会识别值的类型

默认的数字转换优先级：
    complex > float > long >int

    优先级大转小的时候，会自动转化成大类型然后再进行运算。
    强制转换的时候需要加（）
    特别说明complex：
    complex（x）  把x转换为实部x和虚部为零的复数
    complex（x,y） 把x和y转换为实数部分x和虚部y的复数

我们现实的数字和计算机的数字区别：
    计算机里面的数字都是以二进制补码的方式存在的。
        当数字为正数时：原码 = 反码 = 补码
        当数字为负数时：反码 = 原码符号位不变其他取反  补码 = 反码 + 1

        计算机内部的数字运算都是以补码的方式进行运算的。

    位运算：
        &（与） |（或） >>（右移） <<（左移） ~（取反） ^(异或)

    数字的标准函数：
        位运算的优先级 ~ > (<<) > (>>) > & > ^ > |

        标准函数：
            abs 绝对值 
            cmp（x,y） x > y:return 1| x = y:return 0 | x < y:return -1
            max(x,y,z....) 返回最大值
            min(x,y,z....) 返回最小值

    随机数:
        随机数使用时 导入包 import random

        1. random.random() 用于生成一个0 <= n < 1.0 的随机浮点数
        2.random.uniform(a,b) 用于生成一个指定指定范围的随机浮点数
        3.random.randint(a,b)用于生成一个指定指定范围的随机整数（a,b分别是上线）
        4.random.randrange([start],[top],[step]),从指定范围内，按照step递增的集合获取数。
        5.random.choice(sequence) 从序列中获取一个随机元素.
        6.random.shuffle(x[,random]) 用于将一个列表中的元素打乱
        例如：items = [1,2,3,4,5,6] random.shuffle(items)
        7.random.sample(sqeuence,k)从指定序列中随机获取一个指定长度的片断。

2-2数据结构——序列
序列包含了字符串（string）、列表（list）、元组类型（tuple）
三种类型
字符串和元组是固定长度，不能修改。列表可以插入、删除、替换。

    三者的索引值：
        正索引：0 ~ len - 1 和java、C语言一样
        负索引（python独有）：-len ~ -1   -1代表最后一位。

基本操作和切片操作
    基本操作
        obj in seq ：obj是否再seq中
        obj not in seq ：obj是否不在seq中
        seq + seq1 ： 连接序列seq和seq1，两者的序列要一致
        seq * N ：序列重复相加N次
    切片操作
        [index] :取索引index出的元素
        [start:stop] :取所以start到stop的所有元素
        [start:stop:step：在索引start到stop之间，每隔step个取一个元素
序列的内建函数
    len ：返回列表长度
    max/min(seq) :返回列表最大值/最小值
    sum（seq） ： 返回seq的整形的总和
    reversed(seq) :以一个序列作为参数，返回一个逆序访问的迭代器 
    例如：a = reversed([1,2,3])
    zip(seq1,seq2...) :受任意多个（包括0个和1 个）序列作为参数，返回 一个tuple（元组）列表
    例如：zip("123","456")= [(1,4),(2,5),(3,6)]

2-3 字符串
字符串：单引号(‘)、双引号(“”)或者三引号(‘’’/“””)定义字符串，字符串的内容是不可变的。
创建和赋值操作：
str1 = “helloWorld”
str1 = str(10)
str1 = str([1,2,3,4,5])
str1 = str((1,2,3,4,5))
访问：
str1= “helloWorld”
print str1[1] = “e”
print str1[1:3] = “el”
print str1[1:9:3] = “eor”

    字符串的内容不可被修改
    例如 ：str1[1] = 'a' 是错误的

格式化输出
    %c  把数值转化为字符  print("%c" % 65) ==》 A
    %d     把数字转为10进制数 print("%d" % 65)
    %s  把str()把参数转化为字符串 print("%s" % [1,2,3])
    %o %O 将数字转为8进制数 print("%o" % 65)
    %x %X 将数字转为16进制数 print("%x" % 65) 
    %f %F 将数字转为浮点 print("%f" % 65.1) 
    %% 输出% print("%%")
原始字符穿操作符(r/R)
    1.所有的字符串都是直接按照字面意思来使用，没有转义特殊或不能打印的字符
    2.print("\n")和print(r"\n")的不同
        "\n"是一个换行符
        r"\n"是字符\+n，实际值是转义字符\+n组成："\\n"

    字符串如果想要修改或者截取，那就必须要新建一个字符串

    python字符串结尾不需要'\0'结尾i，只是你包含所定义的字符串的值
    python解释器来管理字符串的内存。

字符串的基本操作
     1.+   
     2.*   
     4.[::]  切片操作 
     5.cmp() 比较两个字符串大小  
     6.len()  字符串长度 
     7.max/min() 字符串中最大/最小元素
     8.str() 接收一个任意对象，生成一个str类型的对象
     9.unicode() 接收一个任意对象,生成一个unicode类型对象
     10.chr() 接受参数在0~255之间整数返回对应的字符
     11.unichar() 12.接受参数在0~0xffff之间整数返回相对应的unicode字符
     13.ord() 根据字符返回对应的ASCII

字符串的函数操作
    1.capitalize 字符串第一个字母大写
    2.count(str,x,y) 统计str在字符串索引x~y之间出现次数
    3.endswith(str,x,y) 判断字符串索引x~y之间是否以str结尾，是返回true，否返回false
    4.find(str,x,y) 查找字符串索引x~y之间是否存在str,是返回true，否返回false
    5.index(str,x,y) 同find,如果没找到str，报异常
    6.join(str1) 字符串本身和str1字符串合并
    7.replace(old,new,max) 把字符串中前max次出现的old替换为new,默认值为全部替换。
    8.upper() 返回小写转化为大写副本
    9.lower() 返回大写转化为小写副本

unicode字符串
    键盘输入值然后unicode会找到对应的字模，经过处理会把字模传给显卡，显卡输出到显示器

    unicode:是为了解决传统的字符编码方案的局限而产生的，它为每种 语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换。每个unicode字符占2个字节 

    unicode显示中国两个字的过程:
    先进行encoder（utf-8）编码成 xx\xx\xx\xx 找到对应的字模，然后和字符集GB2312、utf-8、GBK进行匹配，
    最后传入终端设置编码的格式。

unicode编码格式
    ASCII，ISO-8859-1， UTF-8, UTF-16
    UTF-8使用1~4个字节来表示其他语言的字符
    UTF-16使用2个字节来表示其他语言的字符

    和其他字符的转换：
    • str1 = u"一'  u'\u4e00' 
    • utf8= s.encode("utf8")  '\xe4\xb8\x80' 
    • utf8.decoder("utf8")  u'\u4e00' 
    • gbk=s.encode("gbk")   '\xd2\xbb' 
    • gbk.decoder("gbk")  u'\u4e00'

2-4 数据结构——列表
列表是序列式的数据类型，他可以通过索引或者切片操作来访问一个 或者多个连续的元素；列表元素可以改变

    定义初始化：
        mylist = [1,2,3,4,5]
        mylist = list("123456")
        mylist = list(('1','2','3'))
        mylist = range(10) 返回的值是0123456789以列表存在

    列表更新/修改：mylist[1] = 20

基本操作：
    1. []/[:]/[::] 切片操作 
    2. in/not in 成员关系 
    3. +  连接符 
    4. *  重复操作符 
    5. cmp() 比较两个列表 
    6. len()  返回列表元素个数 
    7. sorted() 列表正序
    8. reversed() 列表反序
    9. sum() 统计列表整数的和
    10. zip(seq1..) 根据seq1和其他列表参数生成一个元组列表(以最短的参数为个数)
    11. range([start,] stop[,step]) 根据start和stop指定范围以及step设置步长，生成一个序列

经常使用的函数：
    1. len(mylist) 列表长度
    2. mylist.append(x) 在列表最后添加元素
    3. mylist.insert(i,x) 在列表位置i处插入元素
    4. mylist.remove(x) 删除值为x元素并且长度-1
    5. mylist.reverse() 列表反序
    6. mylist.pop(i) 弹出并删除位置为i的元素
    7. mylist.sort() 对列表进行一个排序

2-5 数据结构——元组
定义：元组是python不可变的对象，如果你要更动这个元组，那么就需要新建一个元组，把数据存入其中

创建：
    tuple1 = ("what","is","python")
    tuple1 = tuple("abcd")
    tuple1 = () 空值
    tuple1 = ("abc",)

访问：
    tuple1 = ('a','b','c','d')
    print tuple1[10]
    print tuple1[0:3]
    print tuple[0:3:2]

更新、删除：
    tp1 = ('a','b')
    tp2 = ('c','d')
    tp3 = tp1 + tp2
    del tp1

函数：
    cmp(tp1,tp1) 比较元组
    len(tp1) 元组长度
    max/min(tp1) 从元组中返回最大值/最小值的项

不可变性：一旦定义就不能改变，除非你新建一个元组
可变：元组和列表的结合，元组不可变，但是元组里面的可变元素还是可以变的。
元组不可变的应用场景：如果我们把数据传给一个不了解的API接口，同时希望数据不能被改变，此时就可以使用元组

深拷贝和浅拷贝：等我了解清楚再来。

2-6 数据结构-字典
定义：字典是Python中的唯一的映射类型。映射类型对象里的哈希值（key）和指向的对象（value）是一对多的关系。
它是一个容器类型，能存储任意个数的Python对象，其中也包括其他容器类型。

直接赋值：
    dict = {}
    dict = {"ip":"127.0.0.1","port":80}

dict方法:传入一个元素是列表的元组作为参数
    dict3 = dict(("ip","127.0.0.1"),("port",90))
    dict3_1 = dict(x = 1,y = 2)
    dict3_2 = dict(**dict3_1)

哈希表：这个是根据key value而直接进行访问的数据结构
dict1            key            key(哈希值)        value
ip:127.0.0.1    ip       hash     134894231556       127.0.0.1
port:90            port  hash     4145156132846        90

字典的访问：dict1["port"]把key转化成hash值，接着找到对应的ID，根据ID找到对应的值。

字典的键值(key)：
    不允许一个键值对应多个值，如果初始化或者更新过程中出现多个键 值，会存储最后一个对应值，其他的会被自动删除。 
    例如：dict1 = {"prot":80,"port":"8000"}
    dict1["port"] = 8000
    len(dict1) = 1

键值(key)是必须能转化成hash值的：
    Python解释器调用hash函数，根据字典中的键值来存储数据位置，如果键值改变，哈希函数会映射到不同地址来存储数据, 这样哈希函数就不能准确地存储或者获取相关数据。

    不可变的类型是可以hash # tuple、str、freezeset
    可变的类型是不可以hash # list、set

字典的基本操作：
    dict1 = {"ip":"127.0.0.1","port":80}

        访问：dict[key]
             dict1["ip"]
             for key in dict1:
                     print("dict[%s] = %s" % (key,dict1[key]))
        更新： dict1["port"] = "8000"

        删除：
            del(dict1["ip"])  删除key为ip的条目
            dict1.clear()    删除dict1中的所有条目
            del(dict1) 删除字典dict1
            dict1.pop("ip") 删除并返回键值为ip的条目
            dict1.popitem("ip")    删除并以元组形式返回字典第一个条目

字典标准函数：dict1 dict2
    str、list、tuple

    list(dict1) 返回dict1的键值从小到大排序的列表
    tuple(dcit1) 返回dict1的键值按键值从小到大排序的元组

    比较运算符cmp(dict1,dict2)，先比较len，再比较各种的key，最后比较value。大于则返回1，反之返回-1，相等返回0

字典相关操作：
    dict1 = {'addr':{'ip':'127.0.0.1','port':80},'msg':18}    字典可以嵌套，value值可以是其他的
    len(dict1)    返回字典（key-value对）的长度
    'key' in dict1 dict1中是否含有'key'键值
    dict1['name'][ip]字典嵌套字典的key值索引
    dict1.has_key('key') 判断字典是否有key键值
    dict1.get(key,default) 如果dict1中有key，返回对应的值，否则返回默认值
    dict1.update(dict2) 合并dict1和dict2
    dict1.setdefault(key，value) 如果字典不存在key，则key默认值为value
    dict1.items() 返回由键和值组成元组列表
    dict1.keys() 返回key列表
    dict1.values() 返回value列表

##参考文献
奇猫的Python教学视频

作者 Luckyboy