python基础教程

函数参数

在 python 中,类型属于对象,变量是没有类型的,

a=[1,2,3]
a="Runoob"
[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是 List 类型对象,也可以指向 String 类型对象。

在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。

  • **不可变类型:**变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
  • **可变类型:**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。

python 函数的参数传递

  • **不可变类型:**类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
  • **可变类型:**类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响

*和**接收参数

(*)会把接收到的参数形成一个元组,而(**)则会把接收到的参数存入一个字典

>>> def foo(*args):
...     print(args)
...
>>> foo("fruit", "animal", "human")
('fruit', 'animal', 'human')

>>> def foo(**kwargs):
...     for key, value in kwargs.items():
...         print("%s=%s" % (key, value))
...
>>> foo(a=1, b=2, c=3)
a=1
b=2
c=3

assert

  1. 使用assert断言是学习python一个非常好的习惯,python assert 断言句语格式及用法很简单。在没完善一个程序之前,我们不知道程序在哪里会出错,与其让它在运行最崩溃,不如在出现错误条件时就崩溃,这时候就需要assert断言的帮助。

  2. python assert断言是声明其布尔值必须为真的判定,如果发生异常就说明表达示为假。可以理解assert断言语句为raise-if-not,用来测试表示式,其返回值为假,就会触发异常。

  3. 下面做一些assert用法的语句供参考:
    assert 1==1
    assert 2+2==2*2
    assert len(['my boy',12])<10
    assert range(4)==[0,1,2,3]

  4. 如何为assert断言语句添加异常参数
    assert的异常参数,其实就是在断言表达式后添加字符串信息,用来解释断言并更好的知道是哪里出了问题。格式如下:
    assert expression [, arguments]
    assert 表达式 [, 参数]

python lambda

例子1. : g = lambda x : x+1
看一下执行的结果:

    g(1)
    >>>2
    g(2)
    >>>3

可以这样理解lambda作为一个表达式,定义了一个匿名函数,上例的代码x为入口参数,x+1为函数体,相当于:

def g(x)
    return x + 1
  • map(): 将序列中的元素通过处理函数处理后返回一个新的列表
  • filter(): 将序列中的元素通过函数过滤后返回一个新的列表
  • reduce():将序列中的元素通过一个二元函数处理返回一个结果

将上面三个函数和lambda结合使用

    li = [1, 2, 3, 4, 5]
    # 序列中的每个元素加1
    map(lambda x: x+1, li) # [2,3,4,5,6]
     
    # 返回序列中的偶数
    filter(lambda x: x % 2 == 0, li) # [2, 4]
     
    # 返回所有元素相乘的结果
    reduce(lambda x, y: x * y, li) # 1*2*3*4*5 = 120

import

import语句作用就是用来导入模块的,它可以出现在程序中的任何位置。

import语句语法如下:

import module
关键字 模块名

from-import语句语法:

from module import name
关键字 模块名 关键字 方法名

import...as

import A as B,给予A库一个B的别称

import module 和 from module import,区别是前者所有导入的东西使用时需加上模块名的限定,而后者不需要。

python导入其他目录下的模块

参考网页

  1. 主程序与模块程序在同一目录下:直接使用

  2. 主程序所在目录是模块所在目录的父(或祖辈)目录

     `-- src
         |-- mod1.py
         |-- mod2
         |     |-- mod2.py
         |-- test1.py
     若在程序test1.py中导入模块mod2, 需要在mod2文件夹中建立空文件\__init__.py文件(也可以在该文件中自定义输出模块接口); 然后使用from mod2.mod2 import * 或import mod2.mod2.
    
  3. 主程序导入上层目录中模块或其他目录(平级)下的模块

     `-- src
     |-- mod1.py
     |-- mod2
     |     |-- mod2.py
     |-- sub
     |     |-- test2.py
     |-- test1.py
     若在程序test2.py中导入模块mod1和mod2。
     首先需要在mod2下建立\__init__.py文件(同(2)),src下不必建立该文件。
    
    	    import sys
    	    sys.path.append("..")
    	    import mod2.mod2
    	    import mod1
    

指定数据类型

指定返回值类型

def test(a:int, b:str) -> str:
    print(a, b)
    return 1000
    
a:int  指定了输入参数a为int类型,
b:str  b为str类型,
-> str  返回值为srt类型。

指定变量类型

class Employee(NamedTuple):
    name: str
    id: int = 3

指定要传入参数的数据类型

当你写的函数方法,要被其他人调用时, 你想让他知道传入参数的数据类型, 可以这样定义

def demo(name: str, age: 'int > 0'=20)->str:  # ->str 表示该函数的返回值是str类型的
    print(name, type(name))
    print(age, type(age))
    return "hello world"  
demo(1, 2)      # 这里的参数1会显示黄色, 但是可以运行不会报错
demo('小小', 2)  # 正常显示

变量作用域

Python是静态作用域语言,尽管它自身是一个动态语言。也就是说,在Python中变量的作用域是由它在源代码中的位置决定的,这与C有些相似,但是Python与C在作用域方面的差异还是非常明显的。

Python的作用域一共有4中,分别是:

    L (Local) 局部作用域
    E (Enclosing) 闭包函数外的函数中
    G (Global) 全局作用域
    B (Built-in) 内建作用域
	以 L --> E --> G -->B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内建中找。
  1. 一般在函数体外定义的变量成为全局变量,在函数内部定义的变量称为局部变量。
  2. 函数内部可以使用global关键字定义全局变量。

变量类型

Python 中的变量赋值不需要类型声明。

Python有五个标准的数据类型:

Numbers(数字)
String(字符串)
List(列表)
Tuple(元组)
Dictionary(字典)

1.数字类型

python支持4中数字类型:int ,bool, float, complex(复数)。

bool值使用True和False表示。

2.Python字符串

s = 'ilovepython' 或s = "ilovepython"

3. Python列表

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]

4. Python元组

元组不能二次赋值,相当于只读列表。
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )

注:元组只有一个数据的时候要加逗号,否则()或被当成运算符

_thread.start_new(insert_frame,(flow,))

5. 字典

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
dict['one'] = "This is one"

print

1. 输出字符串和数字类型

直接输出

print(1)
print("Hello world")

2.变量

无论什么类型的变量都可以直接输出例如:数值,布尔,列表,字典。。。

L = [1, 2, 'a']
print(L)
t = (1 ,2 ,'a')
print(t)

3.格式化输出类似于printf

  1. %字符:标记转换说明符的开始
  2. 转换标志:-表示左对齐;+表示在转换值之前要加上正负号;“”(空白字符)表示正数之前保留空格;0表示转换值若位数不够则用0填充.
  3. 最小字段宽度:转换后的字符串至少应该具有该值指定的宽度。如果是*,则宽度会从值元组中读出。
  4. 点(.)后跟精度值:如果转换的是实数,精度值就表示出现在小数点后的位数。如果转换的是字符串,那么该数字就表示最大字段宽度。如果是*,那么精度将从元组中读出

字符串格式化转换类型

转换类型          含义
d,i                 带符号的十进制整数
o                   不带符号的八进制
u                   不带符号的十进制
x                    不带符号的十六进制(小写)
X                   不带符号的十六进制(大写)
e                   科学计数法表示的浮点数(小写)
E                   科学计数法表示的浮点数(大写)
f,F                 十进制浮点数
g                   如果指数大于-4或者小于精度值则和e相同,其他情况和f相同
G                  如果指数大于-4或者小于精度值则和E相同,其他情况和F相同
C                  单字符(接受整数或者单字符字符串)
r                    字符串(使用repr转换任意python对象)
s                   字符串(使用str转换任意python对象)


>>> pi = 3.141592653  
>>> print('%10.3f' % pi) #字段宽10,精度3  
     3.142  
>>> print("pi = %.*f" % (3,pi)) #用*从后面的元组中读取字段宽度或精度  
pi = 3.142  
>>> print('%010.3f' % pi) #用0填充空白  
000003.142  
>>> print('%-10.3f' % pi) #左对齐  
3.142       
>>> print('%+f' % pi) #显示正负号  
+3.141593  

with

有一些任务,可能事先需要设置,事后做清理工作。对于这种场景,Python的with语句提供了一种非常方便的处理方式。

例如:

file = open("/tmp/foo.txt")
data = file.read()
file.close()

这里有两个问题:
一是可能忘记关闭文件句柄;
二是文件读取数据发生异常,没有进行任何处理,使用异常处理有比较冗长。

下面是with版本的代码:

with open("/tmp/foo.txt") as file:
    data = file.read()

紧跟with后面的语句被求值后,返回对象的 _enter_() 方法被调用,这个方法的返回值将被赋值给as后面的变量。 当with后面的代码块全部被执行完之后,将调用前面返回对象的 exit()方法。Python的with语句是提供一个有效的机制,让代码更简练,同时在异常产生时,清理工作更简单

异常处理

try....except...else的语法:

try:
<语句>        #运行别的代码
except <名字>:
<语句>        #如果在try部份引发了'name'异常
except <名字>,<数据>:
<语句>        #如果引发了'name'异常,获得附加的数据
else:
<语句>        #如果没有异常发生

try-finally 语句无论是否发生异常都将执行最后的代码。

try:
<语句>
finally:
<语句>    #退出try时总会执行

例子:

try:
    1 / 0
except Exception as e:
    '''异常的父类,可以捕获所有的异常'''
    print "0不能被除"
else:
    '''保护不抛出异常的代码'''
    print "没有异常"
finally:
    print "最后总是要执行我"

操作符

  1. !在Python里面是非法的用not取代
  2. Python的逻辑操作有三种:and、or、not。分别对应与、或、非。

Python结构体嵌套结构体

from ctypes import *

class st(Structure):                             # 结构体嵌套结构体
    _fields_ = [('a', c_char_p),
                ('b', c_int)]
age = st()
age.a = bytes('liu',encoding='utf-8')           # 字符串
age.b = 23
class person_Info(Structure):
    _fields_ = [('x', st),                       # 结构体类型
                ('y', c_int),
                ('z', c_float)]
person_liu = person_Info()
person_liu = age

print(person_liu.x.b)
  1. Structure是内置类型

  2. ctypes 支持结构体的使用,从 Structure 类派生,数据放在 _fields_

  3. ctypes 作为 Python 和 C 联系的桥梁,它定义了专有的数据类型来衔接这两种编程语言。

super

super() 函数是用于调用父类(超类)的一个方法.

语法:

super(type[, object-or-type])
  • type -- 类。
  • object-or-type -- 类,一般是 self
  • Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :
class A:
	def add(self, x):
		y = x+1
		print(y)
class B(A):
	def add(self, x):
		super().add(x)
		b = B()
		b.add(2)  # 3

for

python中将一行代码放在for循环那行

s.split() for s in raw_sentences

相当于

for s in raw_sentences:
	s.split()

eventlet超时跳过

执行一条代码时间过长 而且还不报错,卡死在那。还要继续执行下面代码,如何操作。

pip安装 第三方eventlet这个包 – pip install eventlet

import time
import eventlet#导入eventlet这个模块
eventlet.monkey_patch()#会带来兼容性问题,不加又不行


with eventlet.Timeout(2,False):#设置超时时间为2秒
   time.sleep(4)
   print('没有跳过这条输出')
print('跳过了输出')

不太好用

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×