Python的学习记录 学python总结

为什么学习python？

1）之前一直有学习python的想法，在Java和Python之间，我之前的选择是Java，因为时间和精力有限，就选择了一个方向，深入下去。

2）空闲时间实在太多，处理完日常工作，又分出考各种证书的学习时间，还有富裕。干点啥呢，学习python吧。

3）总是听说python在表格处理/自动化运维/网络爬虫/人工智能等领域有对应的实践，那就学习一下呗，所谓技多不压身。

话不多说，开始学习！

第一部分-类型和表达式部分

【注意】：2.7版本之后，print "xxx" 要换成 print("xxx")

Hello，world！

>>> print("Hello world!")
Hello world!

两个数相乘

>>> print(3*6)
18

变量定义

smart_city="网研院"
print(smart_city)
smart_city="智研院"
print(smart_city)

【注意】这里的smart_city = "xxxx"不叫变量赋值，而叫变量绑定，python维护了一个符号表（变量名）以及符合对应的值，这个对应关系就叫做绑定，一个符号可以绑定任意类型的值。

两数相乘

x = input()
y = input()

print(int(x) * int(y))

【注意】input（）函数输入的是字符串格式，所以自己在键盘输入的整数其实并不是正整数，而是字符串形式。所以在执行语句x*y会报错。因为x和y都是字符串形式，不可以相乘。

所以需要进行强制转换。

函数定义

#函数定义
def bi_smart():
    print("联通智能城市研究院")

bi_smart()

强制类型转换

#强制类型转换
print(1+int("1"))
print(str(1)+"1")

输出:

2
11

【注意】：int对字符串进行转换时，要求字符类型是整数int('1'），或者输入的是纯数字 int(1.1)，而不能是int('1.1')这种类型，否则就会报错如下：

ValueError: invalid literal for int() with base 10: '1.1'

字符串

1）python三引号

#字符串:Python 中三引号可以将复杂的字符串进行赋值,三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
print('''python
学习
路线''')

输出

python
学习
路线

2）原始字符串

#原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。
print(r'python 学习\c\d\t')

输出

python 学习\c\d\t

 3）带转义字符的字符串

#带转义字符的字符串
print('python 学习\n路线')

输出

python 学习
路线

序列

1）列表

列表特点：

#列表：列表的数据项不需要具有相同的类型，并且列表是可变的
L1=['abc',1,True,"python"]

增删改查基本操作：

#访问列表中的值,索引访问
L=['abc',1,True,"python"]
print(L[1])
print(L[1:])
print(L[1:3])
#更新列表元素
L.append("Tom")
#删除列表元素
del L[1]
#分片删除
del L[3:]
#分片赋值
L[1:3]=['1','abc',1992]

脚本操作符

#脚本操作符：列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表

#操作符"+",组合
L1=[1,2,3]
L2=[4,5,6]
L3=L1+L2
print("列表之间+组合:")
print(L3)
#列表长度函数，长度
print("列表L1的长度:")
print(len(L1))
#操作符"*"，重复
L4=["smart_city"]
print("重复:")
print(L4*4)
#元素是否在列表中
print("判断元素7是否在列表L1中")
print(7 in L1)
#迭代
print("列表L1迭代输出")
for x in L1:print(x)

输出

列表之间+组合:
[1, 2, 3, 4, 5, 6]
列表L1的长度:
3
重复:
['smart_city', 'smart_city', 'smart_city', 'smart_city']
判断元素7是否在列表L1中
False
列表L1迭代输出
1
2
3

python列表函数&方法

#python列表函数&方法

#比较两个列表的元素：python2中的函数cmp,但是在python3中已经不存在该函数，需要引入operator模块
import operator
L1=[1,2,3]
L2=[4,5,6]
#判断列表是否相等
print(operator.eq(L1,L2))
#判断列表的大小关系:lt(小于)/le(小于等于)/gt(大于)/ge(大于等于)
print(operator.__lt__(L1,L2))

#max函数:返回列表中最大的元素
print(max(L1))

#min函数：返回列表中最小的元素
print(min(L1))

2）元组

特点：不可变

#元组(tuple)：Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
t1=(1,2,3)
print(t1)
#逗号引发的python编译问题,Python具备返回多个值的特性，所以每当我们在一个函数或者方法中返回多个值时，这些值就会被打包成一个元组进行返回

Tuple=[1,2,3],
print(Tuple)
输出：因为一个逗号的存在，列表变成了元组返回
([1, 2, 3],)

3）字符串：python字符串格式化

#python字符串格式化，Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，
#但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

print("学习%s的过程,%s下去" % ("python","坚持"))

输出：

学习python的过程,坚持下去

4）字典：针对字典dict的操作原理同list/tuple基本一致

""" Python字段dict:字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
 """
d={'a':1,'b':2,'c':3}
#打印字典中所有元素
print(d)
#打印字典中对应键的值
print(d['a'])
#根据键删除字典中的元素
del d['a']
print(d)

Python序列解包

#python序列解包，实用的python语法糖
>>> x,y,z=1,2,3
>>> print(x)
1
#*获取的值默认是list
>>> a,b,*c=1,2,3,4
>>> print(c)
[3, 4]
#如果左值比右值要多，那么带*的变量默认为空
>>> A,B,C,*D=1,2,3
>>> print(D)
[]

bool值&bool运算

#bool运算
print(1<2 and 10>11)

#bool值:bool()函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
#bool是int 的子类。
#1.当对数字使用bool函数时，0返回假(False),任何其他值都返回真。
print(bool(0))
print(bool(1))
#2.当对字符串使用bool函数时，对于没有值的字符串(也就是None或者空字符串)返回False，否则返回True。
print(bool())
print(bool(None))
print(bool("abc"))
#3.bool函数对于空的列表，字典和元祖返回False，否则返回True。
print(bool([]))
a=[]
a.append("1")
print(bool(a))
#4.用bool函数来判断一个值是否已经被设置。
x = input('Please enter a number :')
print(bool(x.strip()))

python语句块

#语句块。:开始语法块，缩进的所有内容都是一个语法块
if(10>1):
    print("YES")
else:
    print("NO")

python三元表达式

#python中的三元表达式，python中没有其他语言中的三元表达式，不过有类似的实现方法
a=1
b=2
c=""
c="YES" if a<b else "NO"
print(c)

相等比较

#运算符"=="和"is"的差别:==比较的是内容，is比较的是引用。
a=[1,2,3]
b=a
c=[1,2,3]
print(a==b)
print(a==c)
print(a is b)
print(a is c)

输出

True
True
True
False

循环

#循环：for循环类似C#的foreach，注意for后面是没有括号的，python真是能简洁就尽量简洁。
for x in range(1,3):
    print(x)

for key in {"a":1,"b":2}:
    print(key)

for key, value in {"a":1,"b":2}.items():
    print(key,value)

for x,y,z in [[1,2,3],['a','b','c']]:
    print(x,y,z)

输出

1
2
a
b
a 1
b 2
1 2 3
a b c

 pass、exec和eval

#pass、exec和eval


""" exec 执行储存在字符串或文件中的 Python 语句。

语法：exec(object[, globals[, locals]])

参数：
object：表示需要被指定的Python代码
globals：表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
locals：表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
"""

exec('print(x)',{"x":"abc"})

#eval:可以把字符串里的字符转换为可执行代码，但只支持一行字符。可以返回执行后得到的值

print(eval（'1+2+3+4+5'))

#Python pass 是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
#如果定义一个空函数程序会报错，当你没有想好函数的内容是可以用 pass 填充，使程序可以正常运行。

def passFuc():
    pass

for x in range(1,10):
    if(x==5):
        print(x)
    else:
        passFuc

输出：

abc
15
5

---

 

第二部分-函数

形参和实参之间是按值传递的，当然有些类型的值是引用（对象、列表和字典等）

#函数部分

#基本函数定义：
def func():
    print("Hello,python")

func()

#带单一返回值的函数

def funcWithSingleReturn():
    return "funcWithDataReturn"

print(funcWithSingleReturn())

#带多个返回值的函数
def funcWithMultiReturn():
    return "funcWithDataMultiReturn1,funcWithDataMultiReturn2"
print(funcWithMultiReturn())

#包含两个参数的函数
def funcWithTwoParams(x,y):
    print(x,y)
funcWithTwoParams(1,2)

#形参和实参数量不一致的函数
def funcUncatchNumParams(x,y,*rest):
    print(x,y,*rest)
funcUncatchNumParams(1,2,3,4,5)

#命名参数函数

def funcWithName(x,y,z):
    print(x,y,z)
funcWithName(x=1,y=2,z=3)

#参数中包含默认值的函数
def funcWithDefaultParam(x,y,z=3):
    print(x,y,z)
funcWithDefaultParam(5,4)

#收集命名参数
def func_with_collection_rest_naned_parameters(*args, **named_agrs):
    print(args)
    print(named_agrs)

func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)

#集合扁平化
func_with_collection_rest_naned_parameters([1, 2, 3], {"x": 4, "y": 4, "z": 6}) #这会导致args[0]指向第一个实参，args[1]指向第二个实参。
func_with_collection_rest_naned_parameters(*[1, 2, 3], **{"x": 4, "y": 4, "z": 6}) #这里的执行相当于func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)。

 

---

 

第三部分-作用域

#函数作用域

#局部变量，只有函数执行才会开启一个作用域，输出：1

if(2>1):
     x=1
print(x)

#使用vars()函数可以访问当前作用域的变量,输出：2
y=2
print(vars()['y'])

#局部变量会覆盖隐藏全局变量
#使用global定义变量，可以访问全局变量,输出分别是1和2，因为global修饰了a，此时print输出的全局变量1，但是函数内部又进行了更改，所以在外部输出的是2
#这样也就解决了，在函数内部想使用全局变量，使用之后又再赋值之后外部进行输出或者另作他用

a=1
def funcWithGlobalVar():
    global a
    print(a)
    a=2

funcWithGlobalVar()
print(a)
    
#locals() 函数会以字典类型返回当前位置的全部局部变量。输出：{'args': 2, 'x': 1}

def funcWithLocalVar(args):
    x=1
    print(locals())
funcWithLocalVar(2)


#每个函数定义时都会记住所在的作用域。
#函数执行的时候会开启一个新的作用域，函数内变量访问的规则是：先访问当前作用域，如果没有就访问函数定义时的作用域，递归直到全局作用域。


b=1
def funcWithNewArea():
    c=2
    print(b,c)

#如果在当前作用域出现了b=2赋值语句，则输出的是2,2;如果去掉下面这行赋值语句，会去函数定义的作用域去查找b的值，因为函数定义时也没有赋值，此时会递归到全局作用域，输出的时1,2
b=2
funcWithNewArea()


#变量访问的始终是当前作用域

x=1
def funcWithCurrentVar():
    x,y=2,3
    print(x,y)

funcWithCurrentVar()#输出(2,3)

print(x)#输出1


#Python闭包：关于闭包的解释，来自：https://www.cnblogs.com/s-1314-521/p/9763376.html

#a和b都是外函数的临时变量
def outer(a):
    b=10
    def inner():
        print("python闭包:",a+b)
    #外函数返回内函数的引用
    return inner

demo=outer(5)
#demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
demo()



##函数作为对象
def func(fn, arg):
    fn(arg)

func(print, "hello")
func(lambda arg : print(arg), "hi")

 

---

 

 

第四部分-模块

【定义】：在Python中，一个.py文件就称之为一个模块（Module）

【使用模块的好处】：

 1) 大大提高了代码的可维护性。其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括Python内置的模块和来自第三方的模块。

 2) 使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突

#a.py
print (__name__)
def say_a():
    print("a")

在另一个文件中引入模块a：

#b.py
#这种引入方式，破坏了对命名空间的管理
from a import *

def say_b():
    a.say_a()
    print("b")


print (__name__)
#此处，模块a是被import之后调用，所以__name__属性的值是文件名a
print(a.__name__)

最后，在demo.py中引入模块b，调用a中的函数

#demo.py
import b

print(__name__)


print("分割线------")
b.say_b()
b.say_a()
b.a.say_a()

【注意】："_name"属性，如果当前文件主动运行，该值为"__main__",如果是被其他模块引入，比如在b.py文件中那样,print("a.__name__"),输出的是a模块的名字"a";

 

---

 

 

第五部分-异常管理

 

#异常

#自定义异常:必须继承于BaseException

class SmartException(BaseException):
    print("smart_exception")

#引发和捕获异常

try:
    raise SmartException

except:
    print("捕获SmartException异常")

#捕获多种异常
try:
    raise SmartException
except(SmartException,NameError):
    print("捕获多种异常")

#访问异常实例

try:
    raise SmartException("访问异常实例")
except(SmartException,NameError) as e:
    print(e)

#按类型捕获异常
try:
    raise SmartException
except SmartException:
    print("SmartException")
except TypeError:
    print("typeError")

#try-except-else-finally

try:
    pass
except :
    print("try-except-else-finally")
else:
    print("else结构")
finally:
    print("总会执行finally")

 

---

 

 

第六部分-面向对象编程

这部分内容整合自：面向对象编程 - 廖雪峰的官方网站 (liaoxuefeng.com)

python闭包和装饰器，以及@语法糖

#Python闭包和@语法糖,python装饰器
def log(func):
    def wrapper(*param):
        print("开始调用函数")
        func(param)
        print("结束调用")
    return wrapper


@log
def eat(name):
    print("%s在哭" % name)

eat("小孩子")

函数式编程：

#函数式编程
g=lambda x:2*x+1

print(g(5))


print(list(filter(lambda x: x%2,range(1,10))))

print(list(map(lambda x: 2*x,range(10))))