python基本语法

一、数据类型：

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Sets（集合）

1.创建方式：

1.直接用花括号创建 eg: set1 = {1，2，3，4，5}

2.用set()函数创建 eg: set2 = set([1,2,3,4,5])

2.追加一个元素：

eg: set1 = {1，2，3，4，5}

set1.add(6)

3.删除一个元素：

eg: set1 = {1，2，3，4，5}

set1.remove(5)

4.冰冻一个集合：用frozenset声明

eg: set3 = frozenset([1,2,3,4,5])

• Dictionary（字典） 

字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

1.创建方式：dict{}

eg1: dic_1 = dict(a='hello',b='soaring') #以list方式创建，追加元素举例：dic_1['c'] = 'test'

eg2: dic_2 = dict((('a','hello'),('b','naruto'),('c','soar')))

2.fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值

语法：dict.fromkeys(seq[, value]))

二、定义函数：

1.普通函数

      def MyFunction() :

       MyFunction()

2.可以制定形参的函数

def MyFunction(a,b) :

MyFunction(b=’param1’,a=’param2’)

3.可收集参数的函数

       def MyFunction(*a) :

       print(a[0])

       MyFunction(1,2,3,4,’naruto’)

4.闭包

def funX() :

    x=3

    def funY() :

        nonlocal x

        x *= x

        return x

return funY()

funX()

*如果声明闭包内部的变量为全局变量，则用nonlocal即可

 

5.匿名函数

lambda x : 2*x+1

*用lambda声明匿名函数 x表示参数，可以传多个

eg：l = lambda x,y,z : x*y*z+1

l(2,3,4)

 

6.内置函数

1. filter(None or Function，iterable) 过滤器，将任何非true的数据过滤掉,有两个参数，

第一个可取None或函数名，第二个则是一个或多个序列

eg1:list(filter(None,[1,2,0,False,True])) 返回值 [1, 2, True]

eg2：list(filter(lambda x : x % 2, range(10))) 【range():取一定范围内的整数值，

10代表取0-9的整数值，list()：序列】

2.map(function, iterable, ...) 对指定序列做映射。

eg1:list(map(lambda x : x * 2,range(10))) 返回结果：[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

eg2:list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])) 返回结果：[3, 7, 11, 15, 19]

 

7.递归

1.设置递归层数(默认100层)：

import sys

sys.setrecursionlimit(num)

eg：def factorial(n) :

　　　　　　　　if(n == 1) :

　　　　　　　　　　return 1

　　　　　　　　else :

　　　　　　　　　　return n * factorial(n-1)

 

number = int(input('insert a number :'))

print("%d 's factorial is %d" % (number,factorial(number)))

 

2.斐波那契

def fab(n) :

　　　　　　if n < 1:

　　　　　　　　return -1

　　　　　　if n == 1 or n == 2:

　　　　　　　　return 1

　　　　　　else:

　　　　　　　　return fab(n-1)+fab(n-2)

 

num = int(input('insert a num'))

print(" 共有%d 对小兔兔诞生" % fab(num))

 

8.迭代

eg：

def interation(n):

n1 = 1

n2 = 1

n3 = 1

 

if n < 1 :

return -1

while (n-2) > 0:

n3 = n1 + n2

n2 = n3

n1 = n2

n -= 1

 

return n3

num = interation(35)

if num != -1:

print('gong you %d dui tutu' % num)

 

三、文件读取与操作

f = open(file_url,w):打开一个文件

r:只读打开

w:写入打开，若有原文件则被覆盖

x:操作文件，如文件已存在，操作会报错

a:写入打开，若文件存在则追加写

b:以二进制形式打开

t:以文本形式打开

+:可读可写模式

U:通用换行符支持

f.read(size=-1):从文件读取size个字符。当为负数时，表示读取剩余的所有字符

f.readline():以写入模式打开，如果文件存在，则在末尾追加写入

f.write(str):将字符串str写入文件

f.writelines(seq):向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象

f.seek(offset,from):在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置， 2代表文件末尾）偏移offset个字节

f.tell()：返回当前在文件中的位置

f.close():关闭文件

list(f):读取整个文件内容

 

四、模块操作

import module_name :引入模块 eg:import random

OS模块（操作系统模块）

os.getcwd():返回当前工作目录

os.chdir(path):改变工作目录

os.listdir(path='.'):列举制定工作目录中的文件名

os.mkdir(path):创建一个目录，如目录已存在则抛出异常

os.makedirs(path):递归创建目录，如目录已存在则抛出异常

os.remove(path):删除文件

os.rmdir(path):删除单层目录,若目录不为空则抛出异常

os.removedirs(path):递归删除目录，若目录不为空则抛出异常

os.rename(old,new):将旧文件名命名为新的文件名

os.system(command):运行系统的shell命令

os.curdir:指代当前目录

os.pardir:指代上级目录

os.sep:输出操作系统特定的路径分割符

os.linesep:当前平台使用的行终止符

os.name:指代当前使用的操作系统

 

os.path模块中关于路径常用的函数使用方法

os.path.basename(path):去掉目录路径，单独返回文件名

os.path.dirname(path):去掉文件名，单独返回目录路径

os.path.join(path1[,path2[,...]]):将path1、path2各部分组成一个路径名

os.path.split(path):分割文件名与路径，返回（f_path，f_name）元组

os.path.splitext(path):分离文件名与扩展名，返回（f_name，f_extension）元组

os.path.getsize(file):返回指定文件的尺寸，单位是字节

os.path.getatime(file):返回指定文件最近的访问时间（float型秒数，可用time模块的gtime()或localtime()换算）

os.path.getctime(file):返回指定文件的创建时间（float型秒数，可用time模块的gtime()或localtime()换算）

os.path.getmtime(file):返回指定文件的最新修改时间（float型秒数，可用time模块的gtime()或localtime()换算）

os.path.exists(path):判断指定路径是否存在

os.path.isabs(path):判断指定路径是否为绝对路径

os.path.isdir(path):判断指定路径是否存在且是一个目录

os.path.isfile(path):判断指定路径是否存在且是一个文件

os.path.islink(path):判断指定路径是否存在且是一个符号链接

os.path.ismount(path):判断指定路径是否存在且是一个挂载点

os.path.samefile(path1，path2):判断path1和path2两个路径是否指向同一个文件

 

pickle模块

pickle.dump(list,pickl_file):将一个列表数据写入到pickle文件

pickle.load(pickle_file):读取pickle_file文件内容读出

eg:

import pickle

list = [1,2,3,4,[5,'hello']]

pickle_file = open('my_list.pkl','wb')

pickle.dump(list,pickle_file)

result = pickle.load(pickle_file)

print(result)

pickle_file.close()

 

五、异常处理

1）常用异常

AssertionError:断言语句（asset）失败

IndexError:序列索引超出范围

KeyError:在字典中查找一个不存在的关键字

NameError:访问一个不存在的变量

OSError:操作系统产生的异常（例如打开一个不存在的文件）

OverflowError:数值运算超出最大限制

SyntaxError:语法错误

TypeError:不同类型之间的无效操作

ZeroDivisionError:除数为零

 

2）异常处理

如果检测到try代码块出现异常，剩余代码则不再处理

1)

try:

检测范围

except Exception[as reason]

出现异常（Exception）后的处理代码

eg

try:

f = open('im not a file');

print(f.read())

f.close()

except OSError as reason:

print('file is missing,the reason is : ' + str(reason))

2)

try:

检测范围

except Exception[as reason]

出现异常（Exception）后的处理代码

finally：

无论如何都会执行的代码

 

eg：

try:

f = open('im not a file');

print(f.read())

except (OSError,TypeError):

print('file is missing')

finally:

f.close()

3)

raise 引发一个异常

 

eg：

1. raise ZeroDivisionError

2. raise IndexError('序列索引超出范围的异常')

 

六、对象

1.声明一个类，用 class

eg：class Test: //默认类名首字母大写

2.实例化一个对象

eg：Test() 或者 $obj = Test()

3.调用对象的属性或方法

eg: $obj.method()

如果一个对象中的属性名和方法名一致的时候，属性名会把方法名给覆盖掉

4.特性：

1）封装性

eg: list_1 = [1,2,3,4,5] //list链表本身就是一个list类

2）继承性

eg1: class MyList(list) //继承list类

$list_2 = MyList()

$list_2.append(6)

$list_2.append(7)

$list_2.append(8)

list_2 //[6,7,8]

eg2：

　　import random as r
　　　　　　　　class Fish:
    　　　　　　　　def __init__(self):
        　　　　　　　　self.x = r.randint(0,10)
        　　　　　　　　self.y = r.randint(0,10)

   　　　　　　 　　def move(self):
        　　　　　　　　self.x -= 1
        　　　　　　　　print('my position is:',self.x,self.y)

　　　　　　　　class GoldFish(Fish):
    　　　　　　　　pass

　　　　　　　　class Carp(Fish):
    　　　　　　　　pass

　　　　　　　　class Salmon(Fish):
    　　　　　　　　pass

　　　　　　　　class Shark(Fish):
    　　　　　　　　def __init__(self):
        　　　　　　　　#Fish.__init__(self)//如果不特别说明，子类init会覆盖父级的init，调用父级类中的构造函数可以用此种方法
        　　　　　　 　　super().__init__() //推荐使用super()函数来调用父级
        　　　　　　 　　self.hungry = True

    　　　　　　　　def eat(self):
       　　　　　　 　　if self.hungry:
            　　　　　　　　print('my dream is eating')
            　　　　　　　　self.hungry = False
        　　　　　　　　else:
            　　　　　　　　print('I\'m full that i can\'t eat anyting')

3）多态

eg: class A:

def fun(self):

print('i'm object A')

 

class B:

def fun(self):

print('i'm object B')

 

a = A()

b = B()

a.fun() //i'm object A

b.fun() //i'm object B

 

5.self :代表当前类本身

eg：

class Ball:

　　　　　　　　def setName(self,name):

　　　　　　　　　　self.name = name

　　　　　　　　def kick(self):

　　　　　　　　　　print("my name is %s" % self.name)

 

 

a = Ball()

a.setName('naruto')

a.kick()

#my name is naruto

5.魔术方法

1）常用在初始化一个类实例的时候 __init__(self,param1,param2,...)

eg: class Ball:

　　　　　　　　　　　　def __init__(self,name):

　　　　　　　　　　　　　　self.name = name

　　　　　　　　　　　　def kick(self):

　　　　　　　　　　　　　　print("my name is %s" % self.name)

 

　　　　b = Ball('soaring')

　　b.kick()

#my name is soaring

2) 绑定 __dict__

　　__dict__是一个字典，键为属性名，值为属性值；

　　并不是所有对象都拥有__dict__属性。许多内建类型就没有__dict__属性，如list，此时就需要用dir()来列出对象的所有属性。

　　实例的__dict__仅存储与该实例相关的实例属性，正是因为实例的__dict__属性，每个实例的实例属性才会互不影响。

类的__dict__存储所有实例共享的变量和函数(类属性，方法等)，类的__dict__并不包含其父类的属性。

　　在调用一个类对象的属性或者方法时，最好不要用类名直接调用类内部的属性或者方法，要实例化一个对象，然后再进行对类对象的属性或者方法调用

　　　　　　eg1: 　　　　　　class A：

def test（self）：

　　print("试试就试试")

 

 A.test() #试试就试试　　　　//此种方法不推荐！！！

a = A()

a.test() #试试就试试　　　　//推荐写法

　　　　3）__new__ 实例化一个对象时最先执行，__new__方法主要是当继承一些不可变的class时(比如int, str, tuple)，

　　　　　　提供一个自定义这些类的实例化过程的途径。

　　　　　　eg1:

　　　　　　　　class CapStr(str):
    　　　　　　　　def __new__(cls,string):
        　　　　　　　　string = string.upper()
        　　　　　　　　return str.__new__(cls,string)

　　　　　　　　cap = CapStr('hello')　　//字符串必须要传入

　　　　　　　　cap　　//HELLO

　　　　　　说明：CapStr类继承了不可改变的str类，重写__new__，使小写的字符串变成大写

　　　　　　eg2：　　　　　　　

　　　　　　　　class Singleton(object):

    　　　　　　　　　def __new__(cls):

        　　　　　　　　# 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象

        　　　　　　　　　　if not hasattr(cls, 'instance'):

            　　　　　　　　　　cls.instance = super(Singleton, cls).__new__(cls)

        　　　　　　　　　　return cls.instance

 

　　　　　　　　　　obj1 = Singleton()

　　　　　　　　　　obj2 = Singleton()

 

　　　　　　　　　　obj1.attr1 = 'value1'

　　　　　　　　　　print obj1.attr1, obj2.attr1　　//value1 value1

　　　　　　　　　　print obj1 is obj2　　//True

 

　　　　4) __del__　析构　　只有当删除所有对象的引用，才可能被调用

　　　　　　eg：

　　　　　　　　class DelExp:
    　　　　　　　　def __init__(self):
        　　　　　　　　print('this is init')

    　　　　　　　　def __del__(self):
        　　　　　　　　print('this is del')

　　　　　　　　c = DelExp()　　//this is init

　　　　　　　　d = c

　　　　　　　　e = d

　　　　　　　　del e

　　　　　　　　del d

　　　　　　　　del c　//this is del

 

6.公有和私有

python定义私有属性或方法，是需要在属性或方法前面加“__”（两个下划线）。

私有属性或方法是不允许对象外部直接调用的。但python的私有是伪私有。

eg： class Person:

　　　　　　　　　　__name = "naruto"

　　　　　　　　　　def getName(self):

　　　　　　　　　　　　return self.__name

 

p = Person()

p.getName()

#'naruto'

　　　　　　　　p._Person__name //可直接通过此种方式直接调用对象中的私有属性

#'naruto'

 

7.组合

　　　　　　　没有继承关系的类的处理机制

eg：

class Rabbit:
    　　　　　def __init__(self,x):
        　　　　　　self.num = x
　　　　class Cat:
    　　　　　def __init__(self,y):
        　　　　　　self.num = y
        
　　　　class Zoo:
    　　　　　def __init__(self,x,y):
        　　　　　　self.rabbit = Rabbit(x)
        　　　　　　self.cat = Cat(y)
        
    　　　　　def PrintNum(self):
        　　　　　　list_check = [0,1]
        　　　　　　if self.rabbit.num in list_check and self.cat.num in list_check:
            　　　　　　print("there is %d rabbit and %d cat in the zoo" % (self.rabbit.num,self.cat.num))
       　　　　　　 if self.rabbit.num in list_check and self.cat.num not in list_check:
            　　　　　　print("there is %d rabbit and %d cats in the zoo" % (self.rabbit.num,self.cat.num))
        　　　　　　if self.rabbit.num not in list_check and self.cat.num in list_check:
            　　　　　　print("there are %d rabbits and %d cat in the zoo" % (self.rabbit.num,self.cat.num))
       　　 　　　　if self.rabbit.num not in list_check and self.cat.num not in list_check:
            　　　　　　print("there are %d rabbits and %d cats in the zoo" % (self.rabbit.num,self.cat.num))
        
　　　　zoo = Zoo(2,0)
　　　　zoo.PrintNum()
　　　　#there are 2 rabbits and 0 cat in the zoo

 

　　　　8.对象相关函数：

　1.　issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

　　 issubclass(class, classinfo) classinfo可以是父级类、当前类、object

　2.　isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

　　 isinstance(object, classinfo)　　
　　　　　　　　　　　isinstance() 与 type() 区别

　　　　　　　　　　　　type() 不会认为子类是一种父类类型，不考虑继承关系。

　　　　　　　　　　　　isinstance() 会认为子类是一种父类类型，考虑继承关系。

　　　　　　　　　　　　如果要判断两个类型是否相同推荐使用 isinstance()。

  3.　hasattr() 函数用于判断对象是否包含对应的属性。

　　 hasattr(object, name)

4.　setattr 函数对应函数 getatt()，用于设置属性值，该属性必须存在。

　　 setattr(对象名, 属性名, 属性值)

5.　getattr() 函数用于返回一个对象属性值。

　　getattr(对象名, 属性名[, default，若不写默认值，该属性值不存在时报attrerror错误])

6. delattr 函数用于删除属性

　　delattr(对象名, 属性名)

7. property() 函数的作用是在新式类中返回属性值

　　class property([fget[, fset[, fdel[, doc]]]])　　fget -- 获取属性值的函数;fset -- 设置属性值的函数;del -- 删除属性值函数;doc -- 属性描述信息

　　eg:

　　　　class C(object):
    　　　　　　　　　　　　def __init__(self):
        　　　　　　　　　　　　self._x = None
 
   　　　　　　　　　　　　 def getx(self):
        　　　　　　　　　　　　return self._x
 
    　　　　　　　　　　　　def setx(self, value):
        　　　　　　　　　　　　self._x = value
 
    　　　　　　　　　　　　def delx(self):
        　　　　　　　　　　　　del self._x
 
    　　　　　　　　　　x = property(getx, setx, delx, "I'm the property.")
　　　　　　　　　　　 c = C()

　　　 c.x //None

　　　 c.x = 'hello'

　　　 c.x //hello