python的基础总结

目录

一．数据类型... 2

二．分支... 7

三．循环结构... 8

四.跳出语句... 9

五.函数... 9

六.类与对象... 11

七.模块... 15

八.函数的高级应用... 20

九.异常处理... 23

一．数据类型

(1)number（数字）

int(整型), float（浮点型）等用于存储数值

 类型转换：int(a),float(a)…等，“a”是要转换的存放数值的变量名

(2)string（字符串）

字符串需要用单引号 ’ ’ 或双引号 " " 括起来 三个单引号是注释

输入字符串是变量名=input（）

(3)tuple（元组）

定义

1.变量名= ()          ##空元组的定义

2.变量名=tuple（（值1，值2…））

3.变量名 = ('xy',)   ##单个内容元祖定义 不加逗号为字符串类型

与列表的区别：列表可修改，元组可以修改

元组操作

变量名= （'http','ssh','ftp'）

     1.索引  

print(变量名[1])    #输出第二个元素，ssh

print(变量名[-1])   #输出最后一个元素，ftp

     2.切片

print(变量名[1:])   #打印第一个元素之后的内容

print(变量名[:-1])  #打印最后一个元素之前的内容

print(变量名[::-1])  #倒序输出

    3.重复

print(变量名 * 3)   #输出三遍在同一个元组中

    4.连接

Ser2 = （'nfs','samba'）

print(变量名 + Ser2)  #输出在同一个元组中

    5.判断是否存在集合中

print('nfs' in 变量名)   #判断是否存在

    6.迭代输出

for user in 变量名:

   print(user)

（4）list（列表）

定义；用来存储多个数据，用[ ]存储数据，逗号隔开

创键方法1  lst=[  ]

创建方法2  lst2 = list([   ])

应用

变量名= ['http','ssh','ftp']

     1.索引  

print(变量名[1])    #输出第二个元素，ssh

print(变量名[-1])   #输出最后一个元素，ftp

     2.切片

print(变量名[1:])   #打印第一个元素之后的内容

print(变量名[:-1])  #打印最后一个元素之前的内容

print(变量名[::-1])  #倒序输出

    3.重复

print(变量名 * 3)   #输出三遍在同一个列表中

    4.连接

Ser2 = ['nfs','samba']

print(变量名 + Ser2)  #输出在同一个列表中

    5.判断是否存在集合中

print('nfs' in 变量名)   #判断是否存在

    6.列表嵌套

变量名2 = [['abc','def','www'],[1,2,3],['mike','tony','sun']]

对其索引：print(变量名2[2][1])   #第三个元素中的第二个元素

对其切片：print(变量名2[:][1])   #第二个元素

    7.列表增加元素

变量名.append('firewalld')   print(变量名)    ##append:追加一个元素到列表中

变量名.insert(1,'sa')  #在指定索引位置插入元素  #在第二个元素的位置插入sa作为第二个元素

    8.删除元素

变量名.pop(0)  #弹出第1个元素

变量名.remove('ssh') #指定删除对象的名字 #直接删除

del 变量名  #删除列表

    9.列表的升降

降序：变量名.Sort（）

升序：变量.sort(reverse=True)

（5）set（集合）

变量={值1，值2…   }

变量名=set(  )

集合操作

1.增加一个元素

变量名.add(x)       

2. 删除集合中的所有元素

变量名.clear

3. 删除集合中的一个元素

变量名.discard(x)

4.复制生成新的集合

新变量名=复制变量名.copy()

5.移除元素

移除集合中的某元素。若元素存在，则移除，不存在则报错(产生KeyError异常)常用语报错处理。

语法：变量名.remove()

(6)dictionary（字典）

 定义

变量={“键”：值1，“键”：值2   }

变量=dict{  }

操作

1.取值

Print（变量名[键值]）

2.增加

字典名[键值]=值

3. 删除：索引使用小括号括起来
字典名.pop(‘ia’)

关于列表和字典的高级操作

列表生成式

列表名=[ 变量名  for 变量名 in range（）]

List_b = [b for b in range(1,100)]

字典推导式

语句：字典名={字典内容+循环条件+判断条件【产生条件】}

Dict__a={key:  value for key in ‘pytgon’ for value in range(2)}

二．分支

1）if单分支结构 - 满足某个条件就执行某个操作，不满足就不执行

语法：
            if 条件语句：
                  代码块

2）if双分支结构 - 满足某个条件执行某个操作，不满足就执行另外一个操作
      语法：
            if 条件语句：
                  代码块1
            else：
                                代码块2

3）if多分支结构 - 满足不同的条件执行不同的操作（后面条件是在前面的条件不成立的时候判断的）

语法：

   if 条件语句1：

       代码块1

   elif 条件语句2：

       代码块2

       …

   else:

       代码块n

三．循环结构

1. while 判断条件：

    语句

无限循环：特点是表达式的条件为True，使用 Ctrl+C 来退出当前的无限循环。

无限循环经常用于手动退出

while 循环使用 else 语句：while … else 在条件语句为false时执行 else的语句块

while   条件：

语句

else：

    语句

2.for循环

for 自定义变量 in可迭代对象:

    代码块

else:

    代码块

range()函数：如果需要遍历数字序列，可以使用内置range()函数，它会生成数列（开区间）

range（0，10,  3）3是步长，可以为负数，也可以全是负数

结合range()和len()函数以遍历一个序列的索引

四.跳出语句

break语句：跳出 for和 while的循环体。如果你从 for或while循环中终止，任何对应的下面代码块和循环 else 块将不执行。

for letter in 'Wangdoudou':  # 第一个实例

    if letter == 'g':

        break

    print('当前字母为 :', letter)

continue语句：跳过当前循环块中的剩余语句，然后继续进行下一轮循环

列子：for letter in 'Wangdoudou':  # 第一个实例

    if letter == 'o':  # 字母为 o 时跳过输出

        continue

    print('当前字母 :', letter)

pass语句

pass语句：是空语句，是为了保持程序结构的完整性，不做任何事情，一般用做占位语句，当不确定后续代码怎么写时用

五.函数

一、函数的定义及其应用

函数，是把具有独立功能的代码块组织成为一个小模块，在需要的时候调用函数的使用包含两个步骤

1.定义函数–封装独立的功能

2.调用函数–享受封装的成果

def 函数名():

代码块

函数名命名规则

可由字母，下划线和数字组成不能以数字开头不能与关键字重名，一般用大写字母开头

参数的作用def(参数)

函数，把具有独立功能的代码块组织成为一个小模块，在需要的时候调用函数的参数，增加函数的通用性

1.在函数内部，把参数当作变量使用，进行需要的数据处理

2.函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递

形参和实参

形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用

实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的

函数的返回值

在函数中使用return关键字可以返回结果

调用函数一方，可以使用变量来接收函数的返回结果

局部变量和全局变量

局部变量是在函数内部定义的变量，只能在函数内部使用

全局变量是在函数外部定义的变量，(没有定义在某一个函数内)，所有函数内部都可以使用这个变量

函数的跨文件使用

函数的跨文件调用

模块文件：每一个python源文件都可以是一个模块文件，可以在一个python文件中定义函数或者变量，然后在另一个函数使用import 文件名使用这个模块，导入之后，可以使用模块名.变量或者模块名.函数的方式使用这个模块文件的函数和变量

小知识

if __name__ == '__main__':

        代码块

功能：测试模块的的代码只在测试情况下被运行，而在导入时不会被运行，其它地方不能代用

六.类与对象

使用class关键字定义一个类，类名的首字母一般要大写：

Class Cat:

   A=”人生“     A-----类属性

     def方法1(self,参数列表):

                pass

     def  方法2（self,参数列表）：

                pass

访问

对象名=类名（）

对象名.方法1（）

对象名.方法2（）

关于各种方法的应用

Class ame(object):
    #记录分数
    top_score=0#在外面是类属性
    #初始化方法
    def __init__(self,player_name):
        self.player_name=player_name

    @staticmethod#这是提醒系统这是静态方法，不需要调用实例属性，只是输出语句
    def show_help():
        print("帮助信息：点击大门，让怪物进来")

    @classmethod#这是提醒系统这是个类方法
    def show_top_scre(cls):
        print("历史记录分数%d" % cls.top_score)
    #实例方法
    def start_game(self):
        print("%s 开始游戏。。。" % self.player_name)
#调用游戏帮助
Game.show_help()
#调用历史记录
Game.show_top_scre()
#创建游戏对象
game=Game("关77")
game.start_game()
#关于各种方法的简单应用

关于__del__方法

用于在对象销毁前最后用一次时使用__del__方法

类的私有属性:

    __pri：两个下划线开头，声明该属性为私有，

    不能在类地外部被使用或直接访问。

    在类内部的方法中使用时 self.__pri。

类的方法:

    在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，

    类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

    self 的名字并不是规定死的(因为是形参)，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法

    __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，

    不能在类地外部调用。self.__private_methods。

继承

语法：class  子类名（父类1，父类2….）:

                          Pass

1. 如果子类没有的属性和方法， 则去父类找， 如果父类也没有， 就报错。
2. 继承方法的重写

当父类方法不满足子类需求时，可以重写父类的方法，如果重写的方法里面还需要用父类里的方法时，我们可以通过在重写的方法里面用super（）.父类的方法名就可以访问了

1. 各父类的方法和属性最好不要相同，如有用__mro__方法

Print(子类名.__mro__)

七.模块

关键字import来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。

在调用模块中的函数时，必须这样引用：模块名.函数名

有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，此时可以用下面方法实现：

from模块名import函数名1,函数名2....

from…import

from语句让你从模块中导入一个指定的部分到文件中用

as的使用

import  模块名  as  别名

用与解决两个模块同名的函数导入问题

多态性

#子类和父类存在相同方法时，子类会覆盖父类方法

#运形时总会调用子类方法--> 多态

例子

class Animal(object):
    def run(self):
        print('running...')
    def cry(self):
        print('crying...')
class Dog(Animal):
    def run(self):
        print('dog running...')
    def eat(self):
        print('dog eating...')
class Cat(Animal):
    def run(self):
        print('cat running...')
cat = Cat()
cat.run()
dog = Dog()

对文件的操作

打开和关闭文件open 函数

  用内置的open()函数打开一个文件，创建一个file对象

Flie=open(文件路径，打开方式)

打开方式

1.r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

2.rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

3.r+打开一个文件用于读写。文件指针将会放在文件的开头。

rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

4.w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

5.wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

6.w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

7.wb以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

8.a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

9.ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

10.a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

关闭文件close() 函数，节约资源

Flie.close()

写入write()方法

 write()方法可将任何字符串写入一个打开的文件。

flie.write("可以 ，你做的很好！6666")

写入read()方法

f.read()方法从一个打开的文件中读取一个字符串。

readline()方法

f.readline() 会从文件中读取单独的一行。

rename()方法

rename()方法需要两个参数，当前的文件名和新文件名。

import os

重命名文件too.txt到f.txt。

os.rename("foo.txt", "f.txt")

remove()方法

你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。

关于文件的写入应用

With open (‘文件路径’，打开方式) as f:

八.函数的高级应用

匿名函数

语法：lambda  参数：表达式

用于只需要用一次且简单的表达式

列子：sum=lambda  a,b:a*b

生成器yield

立即返回yield标记的变量或值，再次调用函数时，代码从上次返回yield之后继续执行。

def add(alis):

    for i in alist:

        # yield与return功能类似，返回本次迭代结果

        yield i + 1


alis = [1, 2, 3, 4]

for x in add(alis):

    print(x)      2,3,4,5

迭代器

iter()函数用来生成迭代器，返回可迭代的对象,一个list本身不是可迭代的对象；
next()函数返回迭代器的下一个项目，括号里面的元素必须是的可迭代的对象。

lst=[1,2,30]

for i in iter(lst):

    print(i)

next(iter(lst))    #1,2,30 lst是不可迭代的

高阶函数

map函数的原型是map(fun, ite, …)，它的返回结果是一个列表。

参数fun传的是一个函数名，可以是python内置的，也可以是自定义的。
参数ite传的是一个可以迭代的对象，例如列表，元组，字符串这样的，可以传多个。

def add(x,y,z):

    return x+y+z

list1=[1,2,3]      list2=[1,2,3]     list3=[1,2,3]

res=map(add,list1,list2,list3)

print(res)

#输出：[3, 6, 9]

reduce函数

reduce(fun, seq, ini])

reduce函数接受一个fun和一串seq，并返回单一的值，以如下方式计算：

1.初始，fun被调用，并传入seq的前两个items，计算得到result并返回

2.fun继续被调用，并传入上一步中的result，和seq种下一个item，计算得到result并返回。一直重复这个操作，直到seq都被遍历完，返回最终结果。

现在reduce已经放在了functools中

from  functools import reduce

a=[1, 2, 2, 1, 3, 3, 4, 1]

reduce(lambda x,y:x+y ,a)  #实现加法功能

#17

reduce(lambda x,y:x+y ,a,2)#指定initial值

#19

filter()函数

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表。

filter()语法如下： filter(function,iterable)

                   # 其中function为函数，iterable为序列

def is_odd(n):

    return n%2 == 1

lst1 = filter(is_odd,[1,2,3,4,5,6,7,8,9,10])

# lst = [1,3,5,7,9]

Sorted函数

sorted可以对所有可迭代类型进行排序，并且返回新的已排序的列表。语法如下：

sorted(iterable, cmp=None, key=None, reverse=False)

一共可接受4个参数，含义分别如下：

1.可迭代类型，例如字典、列表、

2.比较函数

3.可迭代类型中某个属性，对给定元素的每一项进行排序

4.降序或升序

九.异常处理

1. try…except结构

try:

        try块

except Exception[as reason]:

        exception块

如果要捕获所有类型异常，可以使用BaseException，即Python异常类的基类，代码格式如下：

try:

        …

except BaseException as e:

        exception块

2.try …except…else结构

带else子句的异常处理结构是一种特殊形式的选择结构。如果try中的代码抛出了异常，并且被某个except捕获，则执行相应的异常处理代码，这种情况下不会执行else中的代码，依赖于try代码块成功执行的代码都应该放到else代码块中；如果try中的代码没有抛出任何异常，则执行else块中的代码。

3.带有多个except的try结构

4. try…except…finally结构

如果try子句中的异常没有被捕获和处理，或者except子句或else子句中的代码出现了异常，那么这些异常将会在finally子句执行完成后再次抛出。finally中的代码也可能会抛出异常，使用带有finally子句的异常处理结构时，应尽量避免在子句中使用return语句

常见异常

BaseException 所有异常的基类
SystemExit 解释器请求退出
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
FloatingPointError 浮点计算错误
ZeroDivisionError 除(或取模)零 (所有数据类型)
ImportError 导入模块/对象失败
IndexError 序列中没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)

异常的传递

def input_passwd():

    pwd = input('请输入密码: ')


    if len(pwd) >= 8:

        return pwd


    print('主动抛出异常')

    ex = Exception('密码长度不足!')

    raise ex    #主动抛出异常使用raise

try:

    print(input_passwd())    #调用函数

except Exception as r:    #其他异常情况...

print(r)

十．运算符 功能说明

+  加法，列表、元组、字符串合并与连接，正号

-  减发，集合差集，相反数

*  乘法，序列重复

/  除

// 求整商，若操作数中有实数，其结果为实数形式的整数

%  求余数，字符串格式化

** 幂运算

<、<=、>、>=、==、！= 值大小比较，集合的包含关系比较

or 逻辑或

and    逻辑与

not    逻辑非

in 成员测试

is 对象同一性测试，即测试是否为同一个对象或内存地址是否相同

|、^、&、<<、>>   位或，位异或，位与，左移位，右移位