Python笔记——常用基础知识

Python基础知识

一、总述：

此部分包含Python所有有关基础知识，涉及：命名、变量、数据类型、数据结构等方面的基础知识

二、命名

1.标识符：

• （1）命名：首个字母必须为字母表中的字母（包含大小写）或下划线（_），其他字母可以为字母表中的字母、数字、下划线
• （2）大小写：标识符对于大小写敏感
• （3）Python关键字：'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'，命名不能以关键字命名

2.命名习惯：

• （1）类名：类名首个字母大写，采用驼峰式风格
• （2）常量：全大写字母+下划线，如：PI=3.14
• （3）函数和方法：首个字母小写，其他字母可含下划线，特殊方法（如__main__首字母、末尾字母为双下划线）
• （4）参数：使用小写字母+下划线

3.命名原则

• 简单、明确、易于理解：使用一定的缩写简化名称，同时简化后的名称要利于理解

三、风格

1.分号

• 不在每行命令后加分号（区别于C/C++/Java，Python分号可加可不加），也不要用分号将两条命令放在同一行（如：num1 = 1; num2 =2;）

2.行长度

• 每行不超过80个字符
• 特殊情况：
  • （1）长的导入模块语句
  • （2）注释里的URL（可单独将长的URL放在一行）
• 注意：Python会将圆括号“（）”、中括号“[ ]”、花括号“{ }”中的行隐式的连接起来，不需要再用反斜杠“ \ ”连接行（其余不包含括号的情况需要使用反斜杠来分行）

if (width == 0 and height == 0 and
         color == 'red' and emphasis == 'strong'):

3.括号

• 返回语句或者条件语句中不要使用括号
  • 如：if x and y:、return foo

4.缩进

• 用4个空格来缩进代码，不要使用Tab以及Tab和空格的混用
• 行连接时：
  • （1）垂直对齐换行元素
  • （2）使用4个空格的悬挂式缩进（此时函数或者方法、字典的第一行不要有参数）如：

    foo = long_function_name(
               var_one, var_two, var_three,
               var_four)
    

    foo = {
               long_dictionary_key:
                   long_dictionary_value,
               ...
           }
    

5.空行

• 顶级定义（如：函数定义、类定义）：空两行
• 方法定义之间：空一行

6.空格

• 括号内（包括圆括号、中括号、花括号）：不要有空格，
  • ×：spam( ham[ 1 ], { eggs: 2 }, [ ] )
  • √：spam(ham[1], {eggs: 2}, [])
• 不要在逗号、分号、冒号前面加空格
• 二元操作符两边的都加上一个空格，如：x == 1（‘=’在用于指示关键字参数或默认参数值时，不要在其两侧使用空格）

7.导入格式

• 每个导入应该独占一行

8.类

• 如果一个类不继承自其他类，就显示地从object继承（嵌套类也一样）

四、基本数据类型（内置）

1.数值类型

• （1）分类：int（整数）、long（长整型）、float（浮点型）、bool（布尔类型）、complex（复数）
• （2）特点：
  • 1）数值类型是不可改变的数据类型，改变数据类型会新分配一个对象
  • 2）可以通过del删除单个或多个对象的引用，如：del var1[,var2[,var3[....,varN]]]]
  • 3）使用前不需要声明数据类型

2.序列类型

• （1）分类：list（列表，用” [ ]“标识，内部元素用逗号隔开）、tuple（元组，用”( )“标识，内部元素用逗号隔开，不允许更新)
• （2）特点：
  • 1）列表、元组都支持字符、数字、字符串的顺序存储
  • 2）列表可通过下标对其中存储的值进行切割（默认从0开始，-1为最后一个元素）
• （3）列表常用方法
  • 定义列表：motorcycles = ['honda', 'yamaha', 'suzuki']，适用1）、2）、3）
  • 1）修改列表元素值：
    • motorcycles[0] = 'ducati'，通过下标索引直接修改指定位置的值
  • 2）插入元素：
    • insert（指定索引和值）：motorcycles.insert(0, 'ducati')（在列表中间插入元素，其后的元素都向右移动一个位置）
    • append（指定值，并在列表末尾添加元素）：motorcycles.append('honda')
  • 3）删除元素：
    • del（指定元素位置）:del motorcycles[0]
    • pop（删除列表末尾的元素，同时返回元素值）:popped_motorcycle = motorcycles.pop()（此时列表相当于一个栈）
    • pop（删除指定位置的元素，同时返回元素值）：first_owned = motorcycles.pop(0)
    • remove（指定元素值）:
      too_expensive = 'ducati' motorcycles.remove(too_expensive)
  • 定义列表：cars = ['bmw', 'audi', 'toyota', 'subaru']，适用4）、5）、6）
  • 4）列表排序：
    • sort:cars.sort()，对列表中的元素进行排序，并永久修改了列表元素排序顺序（此列子按照字母顺序排序,在方法中加入参数：reverse=True可按照与字母相反的顺序排列）
    • sorted:sorted(cars)，对列表临时排序，返回临时排序后的列表，但是原始列表cars的元素并没有改变
  • 5）返回列表：
    • reverse:cars.reverse()，反转列表中的元素的排列顺序，并永久修改元素的排列顺序
  • 6）确定列表长度：
    • len:len(cars)
• (4)列表常用操作
  • 定义列表：magicians = ['alice', 'david', 'carolina']
  • 1）遍历列表（for循环）：
    • for magician in magicians:，这行代码获取 magicians中的第一个值alice，并存储到magician中，再执行for循环内的代码，即相对于for循环缩进的代码，执行完毕后并且程序没有跳转，若列表中仍有元素没有遍历完则返回第一行（for循环开始的地方）继续将下一个值存储到magician中（magician为临时变量，可以指定任何名称，通常为名称单数/列表名称的单数）
    • 注意：注意控制缩进，for循环内的代码通常用缩进区分
  • 2）创建数值列表
    • range:range()生成一系列的数字（但并不是列表），如创建1~5：range(1,6)，转换为数字列表：numbers = list(range(1,6))
    • 注意：range()代码块的差一行为
  • 3）数值列表统计：digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
    • 最小值：min(digits)
    • 最大值：max(digits)
    • 求和：sum(digits)
  • 4）列表解析：
    • 作用：生成指定的列表
    • 方法：squares = [value**2 for value in range(1,11)] ，生成1~10的平方的数值列表
    • 过程：squares为指定的列表名称，value**2为指定的表达式，for循环用于给表达式提供值（具体赋值过程见上述遍历列表操作）
    • 注意：for循环结尾没有冒号
  • 5）切片：
    • 定义列表：players = ['charles', 'martina', 'michael', 'florence', 'eli']
    • 方式：指定第一个到最后一个元素中间的任何一个索引
    • 从列表开头开始：players[:4]
    • 终止于列表末尾：players[2:]
    • -1代表末尾元素：players[2:-1]
    • 最后三名队员：players[-3:]（负数的绝对值代表从列表最后一个元素开始向左数第几个元素）
    • 遍历切片：for player in players[:3]:
    • 复制列表：friend_foods = my_foods[:]（此时my_foods[:]只是原列表的副本，friend_foods 与my_foods是两个不同的列表，两个列表对元素进行操作互不影响，若friend_foods = my_foods则两个变量名称指向同一个列表，互相之间进行元素操作是对同一个列表进行的）
• （5） 元组常见操作
  • 1）定义元组：dimensions = (200, 50)
  • 2）修改元组值（整体赋值）：dimensions = (400, 100)

3.映射类型

• （1）分类：dict（字典）

• （2）特点：

  • 1）字典是无序的对象集合（存储键值对的无序组合）
  • 2）字典按键存取
  • 3）键在字典中是唯一不重复的，值是可以重复的

• （3）字典常用操作

  • 1）定义：alien_0 = {'color': 'green', 'points': 5}或定义空字典：alien_0 = {}
  • 2）访问值：alien_0['color']，通过键来访问值
  • 3）添加键-值对：alien_0['x_position'] = 0，指定键、值来添加键-值对
  • 4）修改值：alien_0['color'] = 'yellow'，指定键来索引到对应的值，并重新赋值
  • 5）删除键-值对：del alien_0['points']，指定键来删除值

• （3）定义格式：字典首行不定义键值对，接下来的键值对缩进4个空格，逗号分隔符放在每行末尾（即使最后一行也可加上逗号）

  favorite_languages = {
      'jen': 'python',
      'sarah': 'c',
      'edward': 'ruby',
      'phil': 'python',
  } 
  

• （4）遍历字典

  • 定义字典：

    user_0 = {
        'username': 'efermi',
        'first': 'enrico',
        'last': 'fermi',
    }
    

  • 遍历键值对：for key, value in user_0.items():，items()方法返回键值对，分别赋值给key和value

  • 注意：字典存储键值对的顺序与返回的顺序并不相同，只能保证键与值每次对应是一致的

  • 遍历键：for key in user_0.keys():，keys()方法返回字典中的键值，并赋值给key，此方法等价于：for key in user_0:，即遍历字典默认遍历所有的键

  • 按顺序遍历j键：定义字典

    favorite_languages = {
    	'jen': 'python',
    	'sarah': 'c',
    	'edward': 'ruby',
    	'phil': 'python',
    }
    

    • for name in sorted(favorite_languages.keys()):，sorted方法对字典中的键进行临时排序（相当于建立了临时的有序列表），name遍历有序列表实现对键的有序遍历

  • 遍历值：

    • for language in favorite_languages.values():，values()方法返回字典中的值，此时未考虑values中重复的值，需要去重则要用set方法将返回的值建立一个集合：for language in set(favorite_languages.values()):

• （5） 字典嵌套：

  • （1）分类：字典可以嵌套在列表中，列表也可以作为值嵌套在字典中
  • （2）作用：
    • 1）字典嵌套在列表中：每个字典看作一个整体/实体，多个具有相似属性的实体组合成一个集合存储于列表中
    • 2）列表嵌套在字典中：解决一对多的问题，使得每一个键能够与多个值相对应

4.集合类型

• （1）分类： set（集合）
• （2）特点：集合中的值是不重复的

5.文本类型

• （1）分类：str（字符串）
• （2）常见方法：（定义：name=" ada love"）
  • 1）首字母大写：name.title()
  • 2）字母全大写：name.uper()
  • 3）字母全小写：name.lower()
  • 4）删除左右两侧空格：name.strip()
  • 5）删除右侧空格：name.rstrip()
  • 6）删除左侧空格：name.lstrip()
• （3）常见操作
  • 连接字符串:通过" + "连接字符串

五、类

1. 基本概念

• （1）定义：用来描述具有相同属性和方法的对象的集合，对象为类的实例
• （2）类变量：也称为类属性，指定义在类中各个方法之外的变量
  • 特点：所有实例化对象都同时共享类变量（为公共资源），通过类名可以调用并修改类变量，且修改后的类变量作用于所有的实例化对象（实例对象名也可以调用类变量，但是无法修改类变量，实例对象调用类变量并对其进行赋值相当于创建了新的实例变量，此时同名的类变量将无法通过实例对象访问，因为类变量与实例变量同名时首选实例变量）
• （3）实例变量：在任意类方法内部，以self为前缀方式定义的变量，也称为实例属性，以此方式定义的变量能够被类中所有方法使用
  • 特点：只作用于调用方法的对象，只能通过实例对象名访问，无法通过类名访问
• （4）局部变量：在类的方法中定义的变量，只能作用与所在方法/函数，函数/方法执行完成后局部变量也会被回收

2.类的常用操作

• （1）__init__() 方法：每次新实例创建时python都会自动运行的一种特殊的方法，方法中的形式参数self是不可缺少的，且必须位于其他形式参数前面，此形式参数是作为实例本身的引用（实例变量的定义也依据此方法），允许每个实例调用的方法的形参中都必须有self（类方法与普通函数的区别）

• （2）访问属性：

  • my_dog.name通过.来访问类/实例属性

• （3）访问方法：

  • my_dog.sit()与访问属性同理
  • 注意方法与属性的区别：是否有括号

• （4）继承：子类继承父类的所有属性和方法

  • 方式：子类的定义的首行括号内加入父类的名字

  class Father(object):
      def __init__(self, name):
          self.name=name
          print ( "name: %s" %( self.name))
      def getName(self):
          return 'Father ' + self.name
   
  class Son(Father):
      def __init__(self, name):
          super(Son, self).__init__(name)
          print ("hi")
          self.name =  name
      def getName(self):
          return 'Son '+self.name
  

  • 初始化：
    • 1）需要继承父类的的构造方法__init__()： 不需要在子类中定义__init__()方法，子类实例化时自动调用父类的构造方法
    • 2）不需要继承父类的构造方法__init__()：子类中重新定义__init__()方法，此时不会再调用父类的构造方法
    • 3）子类重写__init__()方法又需要调用父类方法：使用super关键词，如上图所示
  • 特点：Python在运行时首先搜索类中定义的方法，若类中无法找到，则向上搜索父类直至匹配上，否则报错

• （5）方法重写：父类方法不适用，需要修改父类方法时，在子类重新定义与父类重名的方法

  class Parent:        # 定义父类
     def myMethod(self):
        print '调用父类方法'
   
  class Child(Parent): # 定义子类
     def myMethod(self):
        print '调用子类方法'
  

• （6）类的私有属性和方法：无法在外部被调用的属性和方法

  • 1）私有属性：__private_attrs双下划线开头定义属性名称代表私有属性，内部使用self.__private_attrs需要添加self
  • 2）私有方法：__private_method双下划线开头定义方法名称代表方法为私有方法，无法被实例对象名称/类名调用，内部使用self.__private_methods需要添加self

• （7）下划线命名区别：

  • 1）头尾双下划线：定义特殊的方法（一般为系统定义的名称），如：__foo__、__init__()
  • 2）双下划线开头：私有类型（private）的变量，只允许在类本身访问
  • 3）单下划线开头：protected类型的变量，只允许在本身以及子类中访问

• （8）注意：

  • 类的实例也可以用作属性：self.battery = Battery()其中Battery()为定义的一个类
  • 类能够封装成一个模块（即.py文件），同时一个模块内可以有任意数量且相互存在关联关系的类 ，Python安装的标准库就是一组模块
  • 类名采用驼峰式命名，首个字母大写且不使用下划线，实例名和模块名小写，单个单词之间用下划线隔开