python知识点总结

环境

  • anaconda
  • 安装单纯的python,单独安装各类库。pycharm 注册码在lanyu查询,会更新
  • linux环境下安装python软件在github或者码云获取,文档在获取

基础语法与用法

  • 变量名:_XXX_系统内定的。__私有变量.大小写字母数字下划线构成,数字不能作为开头。变量名都是小写开头(eg. dologin,全小写),函数(eg.\doLogin\do_login,头小写,单词大写)类名大写开头(eg.TopicInfo,头大写,单词大写)
  • 关键字:关键字不可以用为变量名,会出错。
  • 变量与常量:常量(eg.1 ,2 ,3,可以看到内容的),变量(eg. a=123,a=234,a就是变量,定义变量方法为:变量名 = 数据)

基础内容

  • 数据
  1. 不可变数据(number数字,string字符串,tuple元祖)
  2. 可变数据(list列表dictionary字典,set集合)列表和字典常用,必须掌握
  3. 类型判断:type(object)
  4. 类型转换:
  • int(x [,base])
    将x转换为一个整数
  • float(x)
    将x转换到一个浮点数
  • complex(real [,imag])
    创建一个复数
  • str(x)
    将对象 x 转换为字符串
  • repr(x)
    将对象 x 转换为表达式字符串
  • eval(str)
    用来计算在字符串中的有效Python表达式,并返回一个对象
  • tuple(s)
    将序列 s 转换为一个元组
  • list(s)
    将序列 s 转换为一个列表
  • set(s)
    转换为可变集合
  • dict(d)
    创建一个字典。d 必须是一个序列 (key,value)元组。
  • frozenset(s)
    转换为不可变集合
  • chr(x)
    将一个整数转换为一个字符
  • ord(x)
    将一个字符转换为它的整数值
  • hex(x)
    将一个整数转换为一个十六进制字符串
  • oct(x)
    将一个整数转换为一个八进制字符串
  1. 索引:索引值都是从0开始,
  2. 转义:eg(print(‘xxx\nyyy’)=xxx 换行yyy ,print(r'xxx\nyyy)=xxx\nyyy)
  3. 运算符:in/not in是否包含
  4. 格式串:
  • eg.a=123 b=234 print('{},{}'.format(a,b))
  • 使用%占位符eg.a=123 b=234 print('%d,%d'%(a,b)),

列表数据(有序可重复,所有数据都可以放,建议同类数据放到一个list中)

  1. 用法 a=[]
  2. 索引:
    下标索引:索引值从0开始,
    数据内容中如果是另一个列表就用【】【】的方法索引 ,
  3. 遍历:
    for 循环遍历所有数据eg1. for x in list,eg2.for i in range(0,len(list)) list[i]

元祖数据(使用机会较少,不可修改)

  1. 用法 a=(),如果创建只有一个元素的元祖数据,一定要在结尾有(,)逗号
  2. 索引:
    下标索引:索引值从0开始,

数据内容中如果是另一个列表就用【】【】的方法索引 ,

  1. 遍历:
    for 循环遍历所有数据eg1. for x in tuple,eg2.for i in range(0,len(tuple)) tuple[i]

集合数据(有序不重复)

  1. 用法 a={}
  2. 索引:
    下标索引:索引值从0开始,

数据内容中如果是另一个列表就用【】【】的方法索引 ,

  1. 遍历:
    for 循环遍历所有数据eg1. for x in set,eg2.for i in range(0,len(set)) set[i]

字典数据(键值对,非常常用,不可变数据)

  1. 用法 a={key:value},key必须是唯一的
  2. 修改:key=value
  3. 删除:del dict['Name'],dict.clear()全部删除,dict.pop('Name')
  4. 使用:
  • copy() 方法返回一个字典的浅拷贝
    dict1 = {'Name': 'Neuedu', 'Age': 7, 'Class': 'First'}
    dict2 = dict1.copy(),
    print ("新复制的字典为 : ",dict2),
    新复制的字典为 : {'Age': 7, 'Name': 'Neuedu', 'Class': 'First'}
  • get(key, default=None)方法返回指定键的值,如果值不在字典中返回默认值,
    dict = {'Name': 'Neuedu', 'Age': 27}
    dict.get('Age')),
    27
    dict.get('Sex', "NA")),
    NA
  • items()方法以列表形式返回可遍历的(键, 值) 元组列表,
    dict = {'Name': 'Neuedu', 'Age': 7}
    dict.items()
    dict_items([('Age', 7), ('Name', 'Neuedu')])
  • keys() 方法将字典中所有的键返回一个可迭代对象,可以使用list() 来转换为列表,
    dict = {'Name': 'Neuedu', 'Age': 7}
    dict.keys()
    dict_keys(['Name', 'Age']),
    list(dict.keys()) # 转换为列表
    ['Name', 'Age']
    -fromkeys(seq[, value]) 函数用于创建一个新字典,以序列seq中元素做字典的键,value为字典所有键对应的初始值,
    seq = ('name', 'age', 'sex')
    dict = dict.fromkeys(seq)
    print ("新的字典为 : %s" % str(dict))
    新的字典为 : {'age': None, 'name': None, 'sex': None}

流程控制

  1. if 条件表达式1:
    语句块1
    elif 条件表达式2:
    语句块2
    else:
    语句块3
  2. 产生循环数:
    使用随机数,先导入随机数模块,再使用 random.randint(a, b)返回 [a, b] 之间的整数(包含 a 和 b),
    import random
    random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20
    random.randint(20, 20) # 结果永远是 20
    random.randint(20, 10) # 该语句是错误的,下限必须小于上限
    3.循环结构
  • while:
    while 条件表达式:
    语句块
    更新条件表达式
    else :
    语句块
    eg:
    ...
    n = 100
    sum = 0
    counter = 1
    while counter <= n:
    sum = sum + counter
    counter += 1
    print("1 到 %d 之和为: %d" % (n,sum))
    ...
  • for
  • continue:continue 条件满足时,不执行后续的代码,直接进入下次循环.只针对 当前所在循环有效
  • break:break 条件满足时,退出循环,不再执行后续重复的代码.只针对当前所在循环 有效
  • 计数用range()

函数

  1. 用法:
    def 函数名( 形参表 ) :
    函数体
    [ return [ 表达式/函数 ] ]
  2. 类型
  • 无参函数
    def hello() :
    print("Hello World!")
  • 带参函数
    def area(width, height):
    return width * height
  • 空函数
    def nop(): # 一个什么事也不做的空函数
    pass

参数

1.实参:
不可变类型:数字、字符串、元组作为 实参 时,会将副本传递给 形参 ,因此函数内部的修改不会影响 实参 本身,
可变类型:列表、字典、集合作为 实参 时,会将 实参 真正的传过去,因此函数内部的修改也会对 实参 产生影响

  1. 形参:
  • 必选参数(位置参数),要求 实参 必须以正确的顺序和数量传递给 形参 。
    def printme( str ):
    print (str)
    printme() # 报错,实参数量不正确
  • 关键字参数,将 实参 以赋值语句的形式传递给指定的 形参,允许函数调用时参数的顺序与声明时不一致,由解释器负责匹配
    def printinfo( name, age ):
    print ("名字: ", name)
    print ("年龄: ", age)
    printinfo( age=50, name="neuedu" )
  • 默认参数,为 形参 设置默认值,当没有 实参 时使用该值
    def printinfo( name, age = 35 ): # 形参的默认值为35
    print ("名字: ", name)
    print ("年龄: ", age)
    printinfo( age=50, name="neuedu" )
    printinfo( name="neuedu" ) # 在函数中使用age的默认值
    名字: neuedu
    年龄: 50
    名字: neuedu ,
    年龄: 35
  • 不定长参数,当 实参 数量不定时,可以使用不定长参数。
    def printinfo( arg1, *vartuple ):
    print(arg1)
    print(vartuple)
    printinfo( 70, 60, 50 )
    70
    (60, 50)
  • 在Python中 形参可以用必选参数、默认参数、可变参数、关键字参数、命名关键字参数。
    但定义的顺序必须是:必选参数、默认参数、可变参数、命名关键字参数、关键字参数。
    对于任意函数,都可以通过类似 func(*args, **kw) 的形式调用它,无论它的参数是如何定义的
    虽然可以组合多达5种参数,但不要同时使用太多的组合,否则函数接口的可理解性很差。

面向对象(类)

  1. 概念

  • :用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
  • 方法:类中定义的函数。
  • 实例化:创建一个类的实例,类的具体对象。
  • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
  • 局部变量:定义在方法中的变量,只作用于当前实例的类。
  • 实例变量:在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。
  • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
  • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
  1. 基本语法

创建类

class 类名:
      def方法名(self [,参数列表]):
            pass

创建对象
对象变量 = 类名( [ 参数列表 ] )

class Cat:
    def eat(self):
        print("小猫爱吃鱼")
    def drink(self):
        print("小猫在喝水")
tom = Cat()

print(tom)
<__main__.Cat object at 0x00000000029BF0B8>
tom.drink()
tom.eat()

小猫在喝水
小猫爱吃鱼

定义一个属性

class Cat:
    def __init__(self, name):        
        self.name = name  # 添加name属性
    def eat(self):
        print("小猫%s爱吃鱼" % self.name)
    def drink(self):
        print("小猫%s在喝水" % self.name)
tom = Cat("Tom")
tom.eat()
tom.drink()

小猫Tom爱吃鱼
小猫Tom在喝水

类实例

创建家具类
class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area
    def __str__(self):
        return "[%s] 占地面积 %.2f" % (self.name, self.area)

bed = HouseItem("席梦思", 4)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 1.5)

print(bed)
print(chest)
print(table)

[席梦思] 占地面积 4.00
[衣柜] 占地面积 2.00
[餐桌] 占地面积 1.50
创建家类
class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        self.free_area = area
        self.item_list = []
    def __str__(self):
        return ("户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s"
                % (self.house_type, self.area,
                   self.free_area, self.item_list))
    def add_item(self, item):
        print("要添加 %s" % item)

my_home = House("两室一厅", 60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

要添加 [席梦思] 占地面积 4.00
要添加 [衣柜] 占地面积 2.00
要添加 [餐桌] 占地面积 1.50
户型:两室一厅
总面积:60.00[剩余:60.00]
家具:[]
添加家具方法
 def add_item(self, item):
    print("要添加 %s" % item)
    if item.area > self.free_area:
        print("%s 的面积太大,不能添加到房子中" % item.name)
        return
    self.item_list.append(item.name)
    self.free_area -= item.area

异常处理

1.语法(Exception全部异常)

try:
    会引发异常的代码
except 异常类名1 [ as 异常变量名]:
    处理异常1的代码
except 异常类名2 [ as 异常变量名]:
    处理异常2的代码
...
else:
    没有异常时执行的代码
finally:
    无论是否有异常,都会执行的代码
  1. 异常的传递
  • 当函数或方法执行出现异常时,会将异常传递给调用者,如果传递到主程序,仍然没有异常处理,程序才会被终止
  • 因此,只要在合适的层次去捕获错误就可以
def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e:
        print('Error:', e)
    finally:
        print('finally...')
  1. 抛出异常
  • 语法格式:raise [ 异常对象 ]
def input_password():
    pwd = input("请输入密码:")
    if len(pwd) >= 8:
        return pwd
    else:
      ex = Exception("密码长度不够")
      raise ex

try:
    user_pwd = input_password()
    print(user_pwd)
except Exception as result:
    print("发现错误:%s" % result)

文件打开

进程和线程

你可能感兴趣的:(python知识点总结)