python基础合集

一、萌新语法

输入和输出

 print
 1）不带引号，计算机识别，打印结果。print(1+1)——2
 2）带单引号，直接打印引号中内容
 3）带双引号，打印内容中有单引号时，用双引号；使用转义字符+单引号(’)实现单引号
 4）带三引号，实现换行；转义字符“\n”也可以换行
 input()
 name = input(“输入信息”)。使用变量赋值获取输入信息

变量命名

 1）一个词
 2）只包含字母、数字、下划线
 3)不能以数字开头
 4)不使用函数名和关键字

关键字

 None;def;del;try;class;true;and;

条件判断

 1)单项判断：if……:(冒号结尾，执行语句缩进四个空格/tab键)
 2)双向判断：if……else:(条件成立执行if,否则执行else);一个条件满足后不会进行其他判断
 3)多项判断：if……elif……else:
 4)if 嵌套

知识点

 成员运算符：in ; not in 返回True,False.
 身份运算符：is ; not is ；判断两个对象的内存地址空间，返回True,False.
 不可变对象：数值型，字符串，元组：修改之后，对象前后的内存地址改变
 可变对象：列表，集合，字典

二、数据类型

数据类型

 常见的数据类型有：字符串，整数，浮点数，列表，字典，元组，布尔值
 字符串-str:‘python’,‘123’
 整数-int:-1,1,0
 浮点数,带小数点数字-float:-0.15,3.1415
 列表-list:有序集合，可随时增加或者删除元素，标识为[]
 字典-dict:键值对key-value存储，标识为{}
 元组-tuple:类似列表，元素不可修改，标识为()
 布尔值-bool:Ture/False

数据操作

 1)拼接：使用“+”;“%”：print(’%s,%d’%(name,number))
 2)四则运算：+，-，*，/，%，//(取商的整数部分 11//2 = 5)，两个星号(x的y次幂：2星星3 = 8)

数据转换

 1)type():查看数据类型
 2)str():将其他类型强制转换成字符串
 3)int():整数形式字符串强制转化为整数；对浮点数取整；float(3.4)=3
 4)float():整数和字符串(文本型字符串不可)强制转化成浮点数型
 list():将其他类转化为列表
 len():检查数据长度

常用语法

 1)列表：
  提取：偏移量：列表元素位置编号，从0开始
  切片：元素“取”操作；[a:b]，a<=x<b; [a:],x>=a; [ :b],x<b;
  修改：list[0] = ‘xinzhi’,直接对列表元素进行修改
  增加：list.append(‘单一元素’)，添加到列表末尾，不可对列表进行赋值；list1.extend(list2),两个列表合并，也可以用list1+list2
  删除：del list[ : 2],删除0，1位置元素
 2）字典
  提取：键。print(dict[‘key’])
  修改：值。dict[‘key’] = ‘xinzhi’
  增加：dict[‘new key’] = ‘newzhi’,添加在字典末尾
  删除：del dict[‘key’]
  提取所有键：dict.keys()——元组形式
  提取所有值：dict.values()——元组形式
  提取键值对：dict.items()——元组:([(’ ‘:’ ‘),(’ ‘:’ ')])

产生布尔值的表达式print(bool(1)) = 1

  值本身：False,0,’ 空字符串’，[空列表]，{空字典}，None
  比较运算符：== ;!=;>;<;>=;<=;(符号之间不能用空格)
  成员运算符：in/not in
  逻辑运算符：and,or,not

三、循环

 1)for循环(固定次数、自动遍历)：for……in……
in之后可以是：‘ ’：字符串；[’ ‘,’ ']：列表；dict：键；dict.values()：值；dict.items：键值对；range()函数：range(5)0,1,2,3,4；range(1,5)1,2,3,4；range(2,8,2)2,4,6
 2)while循环
  条件为真，执行循环；不定次数，条件为False
 3)break.满足，则结束循环
 4)continue,跳过当前循环，开始下一轮循环

四、函数

函数

 1)函数含义：组织好的，可重复的，实现单一功能的代码
 2)函数种类：自定义函数和内置函数(python中已有；eg:input(),print())
 函数定义格式

变量作用域

 全局变量：全局内生效的变量
 局部变量：函数内或者一个代码块内生效
 global：将局部变量转化为内部变量

内置函数

 abs(); sum(); round(); max(); bool(); sorted(); sort(); str(); all()

函数的4种参数类型

 参数传递:1）形参，定义函数时的参数变量；2）实参，调用函数时，使用的参数变量

 位置实参：

 按照参数位置，依次传递参数

 关键字实参

 不严格按照顺序传递参数，可以通过关键字传递

 缺省参数

 使用最常见的值作为默认值，必须保证带有默认值的缺省参数在参数列表末尾。

 调用函数时，若由多个缺省参数，需要指定参数名

 多值参数

五、类与对象

面向过程：

 分析出解决问题所需的步骤，用函数一步步的实现步骤，使用的时候一个一个依次调用

面向对象：

 把构成问题的事务分解成各个对象，为了描述某个事务在整个解决问题的步骤中的行为

面向对象语言：

 支持面向对象的风格或代码封装在对象的编程技术
面向对象三大特征：封装、继承和多态

类：类是具有共同特征的事物的抽象，是属性和方法的集合。
属性：对象的属性特征
方法：对象所具有的能力动作
对象：实例化类即可得到一个具体的对象，这个对象可以调用类的属性和方法

封装：

 将数据和操作封装为一个有机整体。类中私有成员都是隐藏的，只向外部提供有限的接口，保证内部的高内聚性(模块内)和外部的低耦合性(模块间)。
 类的创建

 创建类的初始化方法：def init(self)，只要创建实例，便自动执行初始化方法下的语句。不用重新进行调用。
只要在类中用def创建方法时，就必须把第一个参数位置留给self,并在调用方法时忽略；当在类的方法内部想调用类属性或其他方法时，就要采用self.属性名或self.方法名

类中方法：静态方法，类方法、实例方法

 python不支持多个的参数重载构造函数。
采用classmethod/staticmethod修饰符，定义出来的函数能够类对象实例化之前调用这些函数，相当于多个构造函数

 类方法的第一个参数(cls)指代类本身。类方法会用这个类来创建并返回最终实例。继承中保证子类使用的可选构造函数构造出来的类是子类的实例而不是父类的实例。
 子类的实例继承了父类的static_method静态方法，调用该方法，调用的是父类的方法和类属性
 子类的实例继承了父类的class_method类方法，调用的是子类的方法和子类的属性

#面向对象之封装
#构造方法和析构方法。不是必要
class Person:
    def __init__(self):
    #构造方法，类实例化时，通常用来初始化对象
        self.name = 'wang'
        self.age = 18 
        #属性定义在构造方法中需要加self.,如果定义在类方法外面，不需要加self.
    def study(self):
        print('study')

    def sleep(self):
        print('sleep')

    def __del__(self):
    #析构方法，类实例化时，通常最后执行，用来回收对象，释放资源
        del self.name
        del self.age

if __name__ == '__main__':
    p = Person()
    #实例化类的时候会自动执行构造方法和析构方法
    p.study()
    p.sleep()

    #Person().study
    #Person().sleep
#实例化了两次，调用两次构造方法和析构方法

继承

重写：父类方法不能满足子类需求，在子类当中定义同名的方法叫做重写
 定义：可以使用现有类的功能，无需重新编写原来的类的情况下对这些功能进行扩展；继承创建的类为“子类”；被继承的为“父类”“超类”；
子类创建的实例，同属于父类。所有实例，都属于根类object

 1）实现继承：

 使用父类的属性和方法而无需额外编码的能力

 2）接口继承：重写

仅使用父类属性和方法的名称，子类必须提供实现的能力(子类重构父类方法)

 3）多重继承

 一个类继承一个或一个以上的父类

#继承：至少基于两个类之间。python支持多继承，从左到右继承，先深度再广度。(先自己，再父亲，再爷爷，后二爸)
#面向对象之继承
class Father:#基类，超类
    name = 'dazhang'
    def eat(self):
        print('Father:eat!')
    def study(self):
        print('Father:study')
#父类方法不能满足子类需求，在子类当中定义同名的方法叫做重写
class Son(Father):#派生类,
    name = 'xiaozhang'
    def eat(self):
        print('Son:eat!')
    def sleep(slef):
        print('Son:sleep')
        super().study()
        #子类调用父类方法使用super()
        
if __name__ = '__main__':
    s = Son()
    s.eat()
    s.name
    #ctrl+b,跳到方法定义的地方

多态

 一种接口多种实现，实现接口的重用
 多态，同一对象，不同解释，产生不同执行结果。具有不同功能的函数可以使用相同的函数名，用一个函数调用不同(内容)功能的函数。一种接口多种实现，实现接口的重用
 多态的前提，首先要有继承关系,其次得有方法重写

class Father:
    def study(self):
        print('Father,study')

class Son(Father):
    def study(self):
        print('Son,study')

if __name__ = '__main__':
    def method(obj):
        obj.study()
    f = Father()
    s = Son()
    method(f)#调用相同名称的方法，传入不同参数对象，展现不同结果，即为多态
    method(s)

重载

 重载：python没有重载。同一类中，定义同名的方法，参数、顺序和类型不一致，就叫做重载

class Test:
    def method(self):
        print('method:1')
        
    def method(self,name):
        print('method:',name)

    def method(self,name,age):
        print('method:'name,age)

    def method(self,age,name):
        print('method:'age,name)

if __name__ = '__main__':
    t = Test()
    t.method()
    t.method('wang')
    t.method('wang',18)
    t.method(18,'wang')
#重载调用时，具体调用哪个重载方法，取决于实参的个数、顺序和类型

六、模块与库

 1)模块类型：内置模块、自定义模块、第三方模块
 2)导入方式：
  import A
  import A as name
  from A import B
  from A import *
 3)if__name__ = “main”: 当.py文件时直接运行，代码块将被运行；当.py文件以模块形式被导入，则不会被运行。

七、文件读写

 1）打开文件。f = open(file,mode,encoding),文件命、操作、编码
 2）读写文件。f.read()/f.readlines()/f.write()/f.writelines()
 3）关闭文件。close()
 4）csv文件：import csv ;writerow();writerows();

八、debug

 try……expect……；