Python速通（不涉及模块与文件）

最新推荐文章于 2024-04-09 15:13:47 发布

XXTongC

最新推荐文章于 2024-04-09 15:13:47 发布

阅读量143

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/XXTongC/article/details/130370813

版权

python初识

本文为本人为学习tensorflow速通python的笔记，并不适用所有人，建议读者起码拥有C、C++、C#、Java中任意一门语言的基础

#这是一个注释
print("代码后面至少有两个空格才能注释")  #这是一个注释

我们也可以这么干：

def func():
    '''Yes
It is a
Function'''
    pass
print(func.__doc__)

这样也能做到输出func里的内容

通过缩进来表示代码块

if True:
    print("1")
else
    print("2")
  print("3")    #此处错误，无法解析print属于那个代码块，一般建议4个空格为一个代码块

在Python中交换两个值

num1,num2=1,2
num1,num2=num2,num1
print(num1,num2)

Python中的输入

num=input('请输入一个数字')  #可在括号内使用单引号来填充提示信息
print("您输入的数字是：",num)

Python的类型转换

鉴定类型的类型：

type(T)

如：

a=0b10100
print(type(a))  #输出：<class 'int'>

转换输出：

print(bin(20))  #2进制输出20
print(oct(20))  #8进制输出20
print(hex(20))  #16进制输出20

python输出复数，格式为：
real+imagj
如下：

a=1+2j
print(a)
print(a.real)
print(a.imag)

列表、元组和字典

列表，使用[]建立的为列表。
元组，使用()建立的为元组，元组不能被更改。
字典，使用{}建立，且形式为{“nameofset”:value1, “nameofset”:value2,…}建立的为字典

format的使用

print(“我叫{}，今年{}岁”.format(“Rice”,18))
注意与C++的区别，双引号后用 . 来调用format，format内放参数，其余与C++一致

随机数

1.randint(a,b) 生成一个[a,b]区间的整数
2.randrange(m,n,[,k]) 生成一个[m,n)之间以k为步长的随机整数
3.getrandbits(k) 生成一个k比特长的随机整数(转换为十进制的数值范围就是2的k次方)
4.choice(seq) 从序列seq中随机选择一个元素
5.shuffle(seq) 将序列seq中的元素随机排列并返回

迭代函数

range(n) 得到从0开始的自然数迭代
range(m,n) 得到m,m+1,m+2,…,n-1的数列
range(m,n,d) 得到m,m+d,m+2d,…到距离n最近的范围内等差值数列

split()切片成员函数，返回值为列表

语法如下：
split([sep=None][,count=S.count(sep)])
sep为可选参数，用于指定分隔符，count也为可选，表示分割次数，默认分隔符在字符串中出现的总此数

count()成员函数

返回一个字符串在一个字符串中出现的此数，没有的话返回0

replace()成员函数

replace(str1,str2)把字符串中的str1换成str2

关于string类的成员函数

1.capitalize() 吧字符串的第一个字符转换为大写

2.center(width,fillchar) 返回一个原字符串居中，并使用fillchar填充至长度width的新字符串

3.isalnum() 如果string至少有一个字符并且所有字符都是字母或数字，则返回True，否则返回False

4.isalpha() 如果string至少有一个字符并且所有字符都是字母，则返回True，否则返回False

5.isdigit() 如果string只包含数字，则返回True，否则返回False

6.isnumeric() 如果string中只包含数字字符，则返回Ture，否则返回False

7.endswith(obj,beg=0,end=len(string)) 检查字符串是否以obj结束，如果beg或者end已指定，则检查指定的范围内是否以obj结束，如果是，则返回True，否则返回False

8.expandtabs(tabsize=8) 把字符串string中的tab符号转为空格，默认的空格数tabsize是8

9.islower() 如果string中包含至少一个区分大小写的字符，并且所有这些(区分大小写)字符都是小写，则返回True，否则返回False

10.find( str2 , beg , end=len(str1) ) 检测字符串str1中是否包含子字符串str2，如果指定beg(开始)和end(结束)范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，则返回-1

关于列表的使用

使用 [] 创建的叫列表，可修改元素。

列表嵌套

python的列表可如此嵌套，可理解为多元数组的实现：

num = [["list1",1,2,3],["list2",4,5,6],["list3",7,8,9]]
print(num)
print(num[1])
print(num[1][1])

输出：

[['list1', 1, 2, 3], ['list2', 4, 5, 6], ['list3', 7, 8, 9]]
['list2', 4, 5, 6]
4

列表的比较

a=[1,2,3]
b=[4,5,6]
c=a
print(a==b)     #按顺序比较列表元素值是否相等
print(a is c)   #检查是否为同一个对象

列表切片

list_name[ start : end : step ]
指以step的步长(负数时反向截取)从start到 end截取列表。

列表的复制

在python中，复制列表并不能直接 list_1=list_2，这样做使得list_1成为list_2的别名，这同时解释了上述比较时 a is b返回了True，类似于C++的引用别名，如下才是复制：

list_1=[1,2,3]
list_2=list1[:]     #利用切片来实现复制

列表的追加

append() 成员函数可在列表的最后面添加元素，如果将列表作为参数，那么将会将作为参数的列表作为一个元素添加到目标列表中形成嵌套列表。
extend() 使用这个成员函数，可以让作为参数的列表中每个元素单独添加到目标列表中。

注：fruits.extend([‘猕猴桃’])不能写成fruits.extend(‘猕猴桃’)，extend()会将“猕猴桃”作为字符序列分别添加到fruits中，相当于是添加了’猕’,‘猴’,‘桃’。

insert(Index,value) 成员函数可在指定位置插入指定内容。

列表元素的查找

index(beg，end，value) 成员函数会在列表的[beg,end]中搜索是否存在 value并且返回 value所在位置的下标。
count(value) 成员函数返回一个元素在一个列表中出现的次数，没有的话返回0。
value in list 语法可判断元素是否在列表中，是的话返回True，不是返回False。

修改列表元素

list_1[-1]=value 可以将最后一个元素赋值为value。
del list_1[Index] 可以删除列表list_1中下标为Index的元素。
del list_1 销毁list_1列表。
remove(value) 成员函数，删除按顺序与value第一个匹配的元素。
clear() 成员函数，清空列表的元素。

元组

与列表类似，但不支持修改，其余函数通用。

字典

字典是一种key:value的映射集合，其形式如下：

name_age = {'Rice':18,'Johnson':19}

注意key必须唯一且不可变，但value不唯一且可修改，字典内的key和value可以是任何类型。
也可以使用dict()函数创建字典：

myDict = dict(name:'Rice',age:18)

字典的访问

可以通过字典的key来访问value：

print(name_age['Rice'])

但是使用上述方法，当没有对应key值时会抛出错误，可使用
get(key) 成员函数去查找key，并返回对应value值，当没有查到时返回None。

items()、keys()、values()分别以dict_items、dict_keys、dict_values对象返回全部的key-value、key、value。当接收这些值的时候建议将它们转换成列表，如下：

name_age = {'Rice':18,'Johnson':19,'Kelvin':20}
myWholeList = list(name_age.items())
myNameList = list(name_age.keys())
myAgeList = list(name_age.values())
print(myWholeList)
print(myNameList)
print(myAgeList)

输出：

[('Rice', 18), ('Johnson', 19), ('Kelvin', 20)]
['Rice', 'Johnson', 'Kelvin']
[18, 19, 20]

dict.fromkeys(key,value)

myArray = dict.fromkeys(('a','b','c','d','e','f','g','h','i'))    #元组作为参数
myList = dict.fromkeys(['a','b','c','d','e','f','g','h','i'])     #列表作为参数
myDict = dict.fromkeys({'a','b','c','d','e','f','g','h','i'},1)   #字典作为参数，并且全部赋初值为1，默认为None

增加字典元素

当我们增加字典元素时一般会嵌套列表，元组。

修改字典元素

大部分与列表相同，只介绍不同的地方。
update({key:value,…}) 成员函数，在字典后面增加元素。

访问闭包的内部函数

def mysum(isum):
    def gosum():
        print('hello', isum)
    print(':', gosum.__closure__)
    return gosum
itis = mysum("Rice")        #此处接受了内部函数，可通过itis()去调用内部函数
itis()

只需要让外部的函数返回内部的函数名并让变量去接收即可。

装饰器

def funA(fn):
    fn()
    return "this is funA"
def funB():
    print("this is funB")
funB = funA(funB)
print(funB)

def funA(fn):
    fn()
    return "this is funA"
@funA
def funB():
    print("this is funB")
print(funB)

上例两种写法实现效果相同
@funB做了这两件事：
1.将funB作为参数传给funA()函数
2.将funA()函数执行完成的返回值赋值给funB

装饰器总结：装饰器是一种高阶函数，它接收的参数中包含了函数名。装饰器同时也是嵌套函数，在它的代码中要调用扩充功能后的函数。

map()

语法：map(function,iterable,…)
类似于C++中的for_each,作用是对 iterable序列作为参数迭代调用 function（函数名，不能加括号）。可以使用list()将返回值转换为列表来接收。

filter() 过滤器

语法：filter(function,iterable)
filter 对 iterable序列作为参数迭代调用 function函数名，不能加括号），将满足条件的元素依次返回。可以使用list()将返回值转换为列表来接收。

reduce() 函数

语法：reduce(function,iterable[,initializer])
在模块 functools里，reduce第一次会将序列的前两个元素传入 function中计算，之后每一次使用 function的返回值与系列中的下一个参数传入 function中，直至调用到系列的最后一个元素。
initializer 是可选参数，如果有将作为第一个参数传入。

Python的异常捕获

语法：

try:
    语句1
except 异常类型1:
    语句2
except 异常类型2:
    语句3
...
finally:
    语句4

与C++相同，一个try语句可以对应多个except 异常捕获语句，可选是否添加finally 语句作为补集语句。

异常类

Python拥有异常：
1.BaseException 所有异常的基类。
2.Exception 常见的错误基类，包括以下：
3.ValueError 传入无效参数错误；
4.ArithmeticError 数值计算错误；
5.ZeroDivisionError 除/取模时零错误。
6.SystemExit 解释器请求退出

抛出异常

1.raise
语法：
raise [exception[(args)]] args为可选参数，用于描述异常信息。
2.assert 断言语句
语法：
assert expression expression需为一个返回bool类型的语句，如果结果为True则运行assert下的语句，否则抛出 AssertionError错误。
断言语句的作用：
1.防御性编程。
2.运行时对程序逻辑的检测。
3.合约性检查（如前置条件、后置条件）。
4.程序中的常量。
5.检查文档。

自定义异常

这在Python中使用class 来实现，实例如下：

class myExceptionError(Exception):      #括号内的Exception告诉编译器我们自定义的异常是Exception的派生类，故Exception也可以捕获我们自定义的异常。
    def __init__(self):
        self.n='This is my exception'
def foo(num):
    try:
        if num==1:
            raise myExceptionError
    except myExceptionError as e:
        print(e.n)
    else:
        print(num)
foo(1)

Python的面向对象

Python的类名首字母按约定应大写。
类的声明、定义与实例化：

class MyClass:
    mydeclarations='This is my class'
    def show(self):             #这里的self是必须的
        print(self.mydeclarations)
class1=MyClass()
class1.show()

构造函数与析构函数

语法：

def __init__(self,...):  #这里分别有两个下划线，可别只写一个咯；和C++一样不写的话编译器会提供默认的代码块无内容的构造函数
    #初始化代码块
def __del__(self):
    #析构函数代码块

神奇的str()方法

当我们使用print()函数打印class1时输出的是class1的类型信息：

<__main__.MyClass object at 0x000001F03AE8E470>

我们可以通过__str__()方法来改变类型实例化签名作为参数时的输出

class MyClass:
    mydeclarations='This is my class'
    def show(self):             
        print(self.mydeclarations)
    def __str__(self):          #看这！
        mystr='This still is my class'
        return mystr
class1=MyClass()
print(class1)

输出：

This still is my class

类属性

类属性可分为三个类型：
1.类体中、所有方法之外：此范围定义的变量称为类属性或类变量。
2.类体中、所有方法内部：以“self.变量名”的方式定义的变量称为实例属性或实例变量。
3.类体中、所有方法内部：以“变量名=变量值”的方式定义的变量称为局部变量。

实例方法、类方法与静态方法

类方法在方法前添加： @classmethod 修饰符
具静态方法在方法前添加： @staticmethod 修饰符
实例方法没有前缀需要添加。
1.实例方法、静态方法、类方法三者中除了实例方法被类调用时要将实例化对象传递给self外，另外两个都可以直接用类或者是类的实例化对象调用。
2.类方法和静态方法主要用于不创建实例化对象的情况下，因为如果每次调用类中的方法时都创建实例化对象，会对系统造成很大的压力，造成系统资源浪费。
3.实例方法第一个参数为self，静态方法与类无关联，类方法第一个参数为cls，相当于将类当作对象进行了传递。

继承

Python支持多继承，可以有多个父类，当出现同名函数时，以继承时的先后顺序决定继承哪个父类的重名函数。
继承语法：

class 派生类(父类):
    ...

重写方法

同其它语言不一样，Python会默认继承父类的构造函数与析构函数。
派生类可以使用： super()函数调用基类的构造函数，这点和Java相似，或者直接通过类名调用父类的构造函数，如下：

def __init__():             #第一种方法
    super().__init__()
    ...

def __init__():             #第二种方法
    父类的函数名.__init__()
    ...

在方法重写时，派生类同名同参方法下改变代码块内容即可。当想要再次调用父类同名方法时有以下三种方法：
1.父类名.父类方法(self)
2.super(子类名,self).父类方法()
3.super().父类方法()

多态

满足多态的条件：
1.继承：多态一定发生在子类和父类之间。
2.重写：子类重写了父类的方法。

class A:                    #这是父类
    def Show(self,other)    
        other.func1         #这多个参，改变一下调用方法就变成多态了....
        other.func2

运算符重载

Python为我们准备好了固定的函数名去自定义重载运算符，语法如下：

def 运算符对应函数名():
    ...
    return ...      #运算符重载记得要返回值，不能是一个空返回函数

接下来是运算符对应的方法名(在类内定义时相应参数应有self和可选参数other)：

+ : __add__()   
- : __sub__()   
* : __mul__()   
/ : __div__()   
< : __lt__()
== : __eq__()
len()对象长度 : __len__()
print : __str__()
or 或运算 : __or__()