《Python编程:从入门到实践》学习汇总

Pycharm使用方法:
    Debug:  开始Debug:shift+F9
            Debug到下一个断点:F9或F8
            停止:Ctrl+F2
            查看调试时的变量信息看下方信息栏的Debugger;查看输出看Console

Python编程:从入门到实践
    python对于一个变量名并不作固定的数据类型绑定，当存入数据形式为字符串时，它就是一个字符串，当存入一个int时，它就是一
        int，而再放入一个字符串/列表/集合时，它又变成了一个字符串
    Python中的变量(包括字符串)拷贝存储方式与c相同，但直接在列表，元组，字典间赋值时要注意了，默认为浅拷贝
    通用函数：
        list(?)         转化为一个列表
        str(int num)    返回值为和num相同的字符串
        sorted(iterable) 对iterable列表排序，但对原列表不作任何改变，会返回排序后的列表
        len(iterable)   获取iterable列表的长度，返回值即为其长度
        max/min(iterable) 返回列表中元素的最大值/最小值
        sum(iterable)   返回列表中元素的值的总和
        set(list)       将列表转化为集合
        raw_input('str')    先输出str作提示信息,再进行输入操作，返回值为输入内容所表示的字符串
        int('str')      将str所表示的内容转换成int类型的数据



Python 笔记
1.
    1.2
        1.2
            字符串的加法，减法
        1.2.3
            字符串的切片（str[0:3])(str[-3:-1])
        1.2.4
            字符串高级方法(类似字符串对象内的函数)
                标题大写:   .title()    str.title()     将每个空白字符的后面的字符换成大写
                大小写:    .upper(),.lower()       全部切换成大写或小写
                切割\分离:     .spilt()    str.spilt('分隔符')  返回值是一个一维字符串的列表，字符数组的行数取决于字符串被分拆成了几段;
                                                        分隔符可以是单个字符，也可以是一个字符串
                替换:     .replace()  str.spilt('str_before','str_after') 返回值为以为字符数组
                去两端空字符:     .strip()    str1.strip('str2')    返回值为字符串，其中会除去str1中所有str2含有的字符,如果不加参数str2，
                                                        则自动去除str2两边的空格字符
                .lstrip()/.rstrip()   str1.lstrip/strip('str1')  返回值也为字符串，和上面基本相同，但只会去掉开头的/末尾的
                查找:     (str1 in str2/iterable2)    返回值为一个布尔值，常用在选择结构中

                .formate()  str1.formate('str2')    将str1中的所有{ }替换为str2，返回值为替换后的字符串

                list1=list2     则将list2的地址赋予list1,只进行浅拷贝
                list1=list[:]   则新生成一个列表，进行深拷贝
                //////////
                随机讲的野生函数
                    print()         类似c++中的cout<<，可以直接输出字符串(不管几维)和数字,后面自动接了一个换行符

                    range(a,b)  表示从a到b的list（官方语言为集合),从a开始小于b
                    len(list1)  返回list1的长度
                    zip(list1,list2...) 提供list1和list2中元素的一对一映射集合，放在另一个地方，返回值为其地址，若对所得
                                    地址再用一次zip，则返回n个值，分别是之前的各个list;
                //////////
    1.3结构
        1.3.1
            1. 函数，注意print会(返回并[可能错了])输出，而return 只会返回;并且，print并不是函数的终点，只有return才是函数的终点
            定义格式:
            def function_name(parameter):
                '''something to describe the function'''
                function_content
                return something
            2.  Python传参也可以使用默认参数(这里叫参数默认值)，不过仍然要把有默认参数的放在最后面.
                    Python传参方式默认方式: 对变量(包括字符串)默认是值传递，对列表之类的默认是地址传值（也算是值传递）
            3.传递任意数量的实参:
                传一个元组:多个单参数
                   def function(*parameter):
                      '''这样定义参数列表后，函数会将任意数量的参数装入一个元组，该元组的名字就是形参的名字)'''
                      '''若这种方法和单个数的形参一起使用，应该将任意数量的放后面，这样Python会先匹配单参数'''
                      '''如果和带默认值的参数混用，python会先填满带默认值的参数'''
                      balabala
                      return something
                传一个字典:多个键-值对:
                   def function(**parameter):
                      '''调用方式:示例:function(key1=value1,key2=value2,key3=value2)'''
                      '''会生成一个字典，填满'''
                      balabala
                   return
            4. python传参新方式:
                关键词传参：
                    例:在函数中定义的形参列表为：(animal_name,animal_type)；调用参数时，可以将实参列表写为(animal_type=
                        hamster,animal_name=niko);python 会自动匹配好参数。
            5.  import关键字
                Python中的import机制:
                    import语句：
                        方式1:    [from \\\filename] import function_name1 [as new_function_name],function_name2(这样就
                                    能值引入某个文件中的某个特定函数)
                        说明: 1.[]表示是可选的，如果不加，就代表从当前目录引入头文件
                              2.from后面，一个点代表上一层目录，几个点代表几层，因此还有2层，3层....
                              3.当然还可以继续加具体的路径值，如:..\ProgramData\Microsoft\Windows\Start Menu
                              4.as就是作为的意思，那么在这个文件中使用as的名字时，就用了它原来的名字的函数
                              5.可以写成[from \\\filename] import *,导入该文件中的所有函数
                        方式2:    [from \\\filename的父文件夹] import filename1 [as new_filename1],filename2
                              1.1.[]表示是可选的，如果不加，就代表从当前目录引入头文件
                              2.from后面，一个点代表上一层目录，几个点代表几层，因此还有2层，3层....
                              3.当然还可以继续加具体的路径值，如:..\ProgramData\Microsoft\Windows\Start Menu
                              4.as就是作为的意思，那么在这个文件中使用as的名字时，就用了它原来的名字的文件
                    import对类的导入:与上述相同，把函数名改成类名
                    import之后的使用:
                        如果是filename里的function函数，则用filename.function(参数列表)调用
            6.Python之禅之函数
                应在定义每个函数之后写好关于这个函数的注释
                如果参数太多，勇敢地换行
                除开头写了注释外，import都尽量写开头           if flag:
                balabala
            [else:
                balabala]
             and相当于&& or相当于||
             新逻辑运算符：   in和not in
             (item in iterable)相当于[在iterable中存在/找得到item]

             布尔数据类型:定义变量时赋值True或false即可
        1.3.3
             for item in iterable:
                do
             item在iterable中一次变换，执行do
             例如 for i in range(0,10)
             print(i)
             就是输出0~10
             关键字 continue 和 break
             可以直接用iterable名的值表示其是否为空545
    1.4
        1.4.1列表
            乘方运算符**
            列表:names=['a','b','c','d','e'];
            追加函数:   names.append(str)  相当与names.pushback()，在尾部增加一个字符串
            插入函数:   names.insert(n,element) 在names[n-1]和names[n]之间插入element
            删除函数:   names.pop(n)    除去names[n],如果没有指定n,则除去最后一个元素;
                                        返回值为弹出的元素
                        names.remove(element)   找出names中第一个完全和element相同的元素，将其除去（是否还有相同的就不管
                        了);无返回值
                        del||||这是一个关键字||||| names[n]
            拼接函数:   names.extend(list2) 在names的后面接上list2的所有元素
            清空:       names.clear()
            排序:       names.sort()  字典序排序,会改变names列表的顺序
                        names.sort(reverse=True) 字典序倒序排序
            反转:       names.reverse() 将原列表反转
            查找函数:   names.index(element)  找出names中第一次出现的和element相同的元素的下标
            统计次数:   names.count()
            列表解析:   squares = [value**2 for value in range(1,11)]

            多重循环:   python: for i,j in zip(list1,list2)
                        c++   : for(int item1=list1[0],item2=list2[0],i=0;
                               i<list1.length()&&i<list2.length();
                               i++,item1=list[i],item2=list[i])
            高级应用:urls=['balbala{}'.format(number) for number in range(1,16)]
                        可见for item in list 不止能用在循环结构语句中，对与所有需要列举的地方，都可以使用，非常灵活.
        1.4.2   字典
            字典就是map,基本使用方式和map一样，不同的是，不需要模板，因此键与值的类型没必要统一
            创建方法
                map={'one'=1,'two'=2,'three'=3}
                map={'one':1,'two':2,'three':3}

            使用方法
                if key in map.keys:  #这里的条件语句是为了避免key不在map里，不然，就会报错
                    print map[key]
                print "three is %(three)s." %d
                    使用：map.get(key) 如果key不存在，则返回none，否则，返回其对应值
                          map[key]
                    删除：map.pop(key)
                    遍历：for key,value in map.items():
                          for key in map.keys():
                          for value in map.values():
        1.4.3   元组和集合--通过《Python编程：从入门到实践》学习
            1.4.3.1 元组(虚拟)
                    元组整体性的list，基本特性和list一样。区别是：不能对其内部元素进行任何修改，但仍可访问内部元素，要修
                    改只能进行整体修改（也就是赋值，重新定义）,list对象的函数对元组(dimension)对象基本可用（除了是修改元
                    素的）
                    定义方法： dimensions=(200,50)
            1.4.3.2 集合(set)
                    集合类似不允许重复的list
            1.4.4   混合嵌套
                    注意：python的各种东西经常都是浅拷贝，包括嵌套的时候，要熟悉copy.deepcopy()的用法

    1.5
        1.5.1 打开文件
            open(name,mode,buffering)   name示例,
    Python编程第9章：类（面向对象）
        格式:
            class class_name(继承的类(这里用f表示父类)）:
                '''注释'''
                def function():
                    return something
        Python 的类中没有数据成员，如果需要，就在写的__init__函数中新定义名称
        Python 的类定义中每次都需要用self表示成员函数要引用的对象名
        在定义该类时可以用方法super.表示对父类的引用，用super.function1相当于调用了f的function1
        猜想:可能调用父类的函数直接调用即可
        [super(f,self).__init__()]
        如果需要去除掉父类中不需要的方法，只用在子类中对该方法重写，名称完全相同即可
        不要忘记了类可以包含(不是说什么继承机制),电动车类里可以含有一个电池的类，并且这个类可以直接用一个语句来实例化(
            self.battery=Battery()
        写代码的另一境界:从显示的逻辑层面考虑问题；考虑的不是Python而是显示情况是怎样的逻辑模型，怎样用代码来表示它

        Python的高级模板:
            1.有序字典（只是给加入的键值(按加入顺序)编了一个序号，在遍历时按该顺序遍历)
                文件: collections.py
                函数名:OrderedDict
                定义方法:m=OrderedDict()
                说明:创建了一个空的有序字典m，遍历的时候先进先出
            2.随机数
                文件: random.py
                函数名:randint
                使用:num=randint(a,b)
                说明:产生从a到b的(伪）随机数，闭区间

        驼峰命名法:
            类名首字母大写，实例(对象)名小写，单词间大写区分
            模块名小写，单词间下划线
            每个类，要一个说明字符串；每个文档，说明字符串；
            一个空行分隔类的方法，两个空行分隔类；
            先导入标准模板，再导入自定义模板，中间用空行隔开；o'k
    Python编程第10章:
        10.1读取文件
            格式1:with open(filename1) [as name1]
                    balabala
            格式2:open (filename2) [as name1]
                    balba
                  close(filename2）
            区别:前面的一种会自ko动找到合适的时机关闭文件，后者要手动调用close()函数
            补充:
                对于filename中转义字符'\'的冲突，有两种解决方案
                    1:在单引号或者双引号的前面加上r，表示'\'表示的时该字符，而不是转义
                    2.像C\C++一样 用'\\'表示
                    3.类函数:
                        举例:
                            str1=name1.read()
                        作用:将文件指针所致文件的全部内容读取到一个字符串中

            逐行读取:
                with open(filename1) [as name1]
                    for line in name1:
                        print(line)
            readlines()方法(类函数):这是文件指针的类的函数，功能为读取文件中的每一行，将各行储存到一个列表中，返回值就是
            这个列表
        10.2写入文件
            with open(filename ,'w') as file3:
                file3.write(str1)
             关于这个写入字符串的函数,以及'w','a','r'就不赘述，不写默认是'r'
             写入的时候自己加换行符
        10.3异常(排除)处理
            格式:
            格式1:
                try:
                     print(5/0)
                except ZeroDivisionError:
                     print("You can't divide by zero")
                这样做之后，在和它同文件夹的文件中遇到try代码中的错误时(不用具体的操作相同，只要系统将他们识别为认定的错误
                    类型)，就不会运行上面的，而是运行下面的代码
            格式2:写成类似if结构
                try:
                     print(5/0)
                except ZeroDivisionError:
                     print("You can't divide by zero")
                只不过这样要放在直接运行的程序中，像一个if结构一样
            补充--常见错误类型:
                1.ZeroDivisionError
                2.FileNotFoundError  找不到文件
                3.ValueError    将字符串转换成整型或者浮点数据时，字符串中含有文本
            pass语句:     pass语句是一个空语句，在这个语句中什么也不做，但可以作为一个以后可能需要填充代码的标志
    Python编程第11章:测试
        11.1测试函数
            格式:
                import unittest
                from name_function import get_formatted_name
                class NamesTestCase(unittest.TestCase):
                   '''测试name_function.py'''
                   def test_firt_last_name(self):
                      '''能够正确处理像Janis Joplin这样的姓名吗'''
                      formatted_name=get_formatted_name('janis','joplin')
                      self.assertEqual(formatted_name,'Janis Joplin')
                unittest.main()
            说明:1.   测试原理是建立unittest.TestCase的派生类，每一个派生类都是一个测试实例
                        Traceback会显示每一个测试-测试中的函数是否通过；每一个测试实例可以包含多项检查，每个检查写成一个
                        检查函数，
                        检查的方法为使用类函数self.assetEqual(parameter1,parameter)，函数会自动反映（而不是返回）两个参
                        数相等的逻辑值到类中，最后返回在Traceback
                 2.   编写的每一个测试实例和测试函数中都必须包含test字样，只有包含test字样unittest类才会检查它
                 3.     unittest Module中的更多断言方法
                        assertEqual(a,b)
                        assertNotEqual(a,b)
                        assertTrue(a)
                        assertFalse(a)
                        assertIn(item,list)
                        assertNotIn(item,list)
                        至于这些断言方法的功能和用法，自己看名字就知道了
                 4.     测试类的方法和测试函数的方法差不多，但编写测试类的代码时心里一定要有这个类，现在这个类处在一个怎
                        样的状态，然后一步一步地调用类函数，最后用以上断言方法检查
                 5.     关于unittest.TestCase的类函数setup()
                            setUp()函数可以写进自己编写的测试实例(类)中,setUp()函数一般专门用来生成测试数据，这组测试数据
                            经常被接下来的各种测试使用(都用这个),
                            setUp()函数的特点，在进行测试时，unittest会先看有没有setUp函数，如果有，则先运行它(生成测试
                            数据)；如果没有，就会运行其他以test开头的函数(我也不知道顺序)