1.注释

单行:# 
多行:三个’单引号’或三个”双引号”

”’

print(“hello world”) 

”’

“””

print(“hello world”) 

“””

2.编码

python2 = assic =  不帮助普通话

文本中有汉语,不管是或不是为注释,python2执行报错。 

消除:程序首行加 #coding=utf-8 或 #*-* coding:utf-8 *-*

python3 = unicode = 默许协助汉语

3.模块:

在Computer程序的费用进度中,随着程序代码越写越多,在壹个文本里代码就能够进一步长,越来越不易于保障。

为了编写制定可保障的代码,我们把无数函数分组,分别放置差别的文本里,那样,种种文件包涵的代码就相对较少,大多编制程序语言都施用这种协会代码的点子。在Python中,二个.py文件就叫做四个模块(Module)。

应用模块有如何利润?

最大的裨益是大大升高了代码的可维护性。其次,编写代码不必从零起头。当四个模块编写实现,就能够被其余地方援引。我们在编写程序的时候,也时不经常援用其余模块,包涵Python内置的模块和根源第三方的模块。

使用模块仍可以幸免函数名和变量名争辨。同样名字的函数和变量完全能够分级设有分裂的模块中,因而,大家团结在编辑模块时,不必思考名字会与别的模块争辩。但是也要留神,尽量不要与内置函数名字争持。点这里查看Python的装有内置函数。

您或者还悟出,要是不一致的人编写的模块名一样如何是好?为了幸免模块名顶牛,Python又引进了按目录来组织模块的章程,称为包(Package)。

举个例证,贰个abc.py的文书正是二个名字叫abc的模块,一个xyz.py的文件正是一个名字叫xyz的模块。

今昔,即使大家的abcxyz那八个模块名字与任何模块矛盾了,于是大家能够透过包来公司模块,制止抵触。方法是挑选贰个顶层包名,比方mycompany,根据如下目录存放:

mycompany
├─ __init__.py
├─ abc.py
└─ xyz.py

引进了包之后,只要顶层的包名不与旁人争辨,那具有模块都不会与人家争持。今后,abc.py模块的名字就改成了mycompany.abc,类似的,xyz.py的模块名改成了mycompany.xyz

请小心,每多少个包目录下边都会有一个__init__.py的文书,那一个文件是必须存在的,否则,Python就把那个目录当成普通目录,而不是贰个包。__init__.py能够是空文件,也得以有Python代码,因为__init__.py自个儿正是一个模块,而它的模块名正是mycompany

就好像的,能够有连串目录,组成多级等级次序的包结构。举比如下的目录结构:

mycompany
 ├─ web
 │  ├─ __init__.py
 │  ├─ utils.py
 │  └─ www.py
 ├─ __init__.py
 ├─ abc.py
 └─ xyz.py

文件www.py的模块名正是mycompany.web.www,四个文本utils.py的模块名分别是mycompany.utilsmycompany.web.utils

注意:和睦成立模块时要小心命名,无法和Python自带的模块名称龃龉。举例,系统自带了sys模块,本身的模块就不行命名称叫sys.py,不然将无法导入系统自带的sys模块。

导入模块:

import package

from Package import specific_submodule

Import 模块名

From 模块名 import 子模块1,子模块2,……

总结:

模块是一组Python代码的集聚,能够应用其它模块,也得以被别的模块使用。

创建本人的模块时,要注意:

  • 模块名要服从Python变量命名规范,不要选择中文、特殊字符;
  • 模块名不要和系统模块名争辨,最棒先查看系统是不是已存在该模块,检查措施是在Python交互处境进行import abc,若成功则证实系统设有此模块。

 

4.输入

name = input(“请输入名字:”)

5.输出

print(“name is %s”%name)  

print(“name:%s, age:%d”%(name,age)) 

print(“name:{0}, age:{1}”.format(name,age)) #(标号可不写,为暗许顺序)

print(“name:{name}, age:{age}”.format(name = “你的名字”,age = 60))

 

import math

print(‘常量 PI 的值近似为 {0:.3f}。’.format(math.pi)) #常量 PI
的值近似为 3.142。

 

table = {‘tbl_a’: 1, ‘tbl_b’: 2, ‘tbl_c’: 3}

print(‘tbl_b: {0[tbl_b]:d}; tbl_a: {0[tbl_a]:d}; tbl_c:
{0[tbl_c]:d}’.format(table))

#tbl_b: 2; tbl_a: 1; tbl_c: 3

 

table = {‘tbl_a’: 1, ‘tbl_b’: 2, ‘tbl_c’: 3}

print(‘tbl_b: {tbl_b:d}; tbl_a: {tbl_a:d}; tbl_c:
{tbl_c:d}’.format(**table))

#tbl_b: 2; tbl_a: 1; tbl_c: 3

6.类型调换

a = int(“100”)  # 转变为数字

a = str(“100“)  # 调换为字符串

7.python2与python3

python第22中学input的内容作为实施的剧情,python3当做字符串。如a = input(“”).
python第22中学的raw_input相当于python3中的inpout。

python2 中援助 <> 是不对等的情致,python3不帮助,应该用 != 表示

8.运算符

一、算述运算符:

1 + 1 = 2 (加法)

4 – 10 = -6 #(减法 – 获得负数或是二个数减去另八个数)

“a” * 5 = “aaaaa” #(乘法 – 八个数相乘或是重临三个被再一次若干次的字符串)

2 ** 3 = 8 #(幂 – 返回2的3次幂)

5 / 2 = 2.5 #凯旋门074网址,(除法)

5 // 2 = 2 #(取商 – 重返商的整数部分)

5 % 2 = 1 #(取余 – 再次来到除法的余数)

二、赋值运算符:

i += 1   等价于 i = i + 1
i  -= 1   等价于 i = i – 1
i  *= 2   等价于 i = i * 2
i  /= 2   等价于 i = i / 2
i  //= 2  等价于 i = i // 2
i  %= 2 等价于 i = i % 2
i  **= 2 等价于 i = i ** 2

9.逻辑运算符

not , and , or

优先级(短路原则):

and:条件1 and 原则2
,假如条件1为假,那么那些and前后八个条件构成的表达式的计量结果就一定为假,就不剖断规范2了

  or:条件1 or
标准2,假使前方的率先个条件为真,那么这些or前后四个原则构成的表达式的乘除结果就一定为真,就不推断标准2了

10.流程

**表达式**操作运算符、常量及变量:

(1)表明式:由操作数和平运动算符组成的一句代码或讲话,表达式能够求值,能够放在”
= “的左边,用来给变量赋值。

(2)操作运算符:

<  小于

<=  小于或等于

>  大于

>=  大于或等于

==  等于,相比对象是或不是等于(注意区分 = ,= 是赋值,==是比较)

!=  不等于

(3)常量:固定不改变的量,字母大写

(4)变量: 存款和储蓄新闻,以往被调用

取名法则:

    • 1.字母数字下划线组成
    • 2.不能够以数字初步,不可能含有特殊字符和空格
    • 3.无法以保留字命名
    • 4.不能够以汉字命名
    • 5.定义的变量名应该有意义
    • 6.驼峰式命名、下划线分割单词

    • 7.变量名分别轻重缓急写

(if…elif…else)

if 条件(如果): 

elif 条件(或如果):  

else否则:

凯旋门074网址 1

注意:

  • 1、各种条件前面要选拔冒号 :,表示接下去是知足条件后要实行的语句块。
  • 2、使用缩进来划分语句块,一样缩进数的口舌在协同组成贰个语句块。
  • 3、在Python中没有switch – case语句。

例:

# 该实例演示了数字猜谜游戏
number = 7
guess = 0
print(“数字猜谜游戏!”)
while guess != number:
    guess = int(input(“请输入你猜的数字:”))

    if guess == number:
        print(“恭喜,你猜对了!”)
    elif guess < number:
        print(“猜的数字小了…”)
    elif guess > number:
        print(“猜的数字大了…”)

# 试行结果:

数字猜谜游戏!
请输入你猜的数字:5
猜的数字小了…
请输入你猜的数字:6
猜的数字小了…
请输入你猜的数字:8
猜的数字大了…
请输入你猜的数字:9
猜的数字大了…
请输入你猜的数字:7
恭贺,你猜对了!

 

if 嵌套:在嵌套 if 语句中,能够把 if…elif…else 结构放在别的三个if…elif…else 结构中。

 

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

例:

num=int(input(“输入三个数字:”))
if num%2==0:
    if num%3==0:
        print (“你输入的数字能够整除 2 和 3”)
    else:
        print (“你输入的数字能够整除 2,但不可能整除 3”)
else:
    if num%3==0:
        print (“你输入的数字能够整除 3,但不可能整除 2”)
    else:
        print (“你输入的数字不可能整除 2 和 3”)

 #
实施结果:

输入一个数字:5
你输入的数字不可能整除 2 和 3

输入二个数字:6
您输入的数字能够整除 2 和 3

 

(while)

while 衡量准则: #(while:当…的时候)

    语句

一、需求当心冒号缩进。另外,在Python中没有do…while循环。

例:while 循环使用 else 语句

i = 0
while i < 5:
    print (i, ” 小于 5″)
    i += 1      # 变量自增
else:
    print (i, ” 等于 5″)

# 输出结果:

0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 等于 5

二、以下实例使用了 while 来估测计算 1 到 100 的总量:

i = 100
sum = 0
counter = 1
while counter <= i:
    sum = sum + counter
    counter += 1
print(“1 到 %d 之和为: %d” % (i,sum))

# 输出结果:

1 到 100 之和为: 5050

(for)

一、for循环能够遍历任何系列的品类,如一个列表可能贰个字符串。

例:

languages = [“C”, “C++”, “Perl”, “Python”]
for x in languages:
print (x)

# 输出结果:

C
C++
Perl
Python

二、以下 for 实例中应用了 break 语句,break 语句用于跳出当前循环体。

澳门凯旋门游戏网址,例:

sites = [“Baidu”, “Google”,”frank-me”,”Taobao”]
for site in sites:
    if site == “frank-me”:
        print(“笔者的网站”)
        break
print(“循环数据 ” + site)
else:
    print(“到此甘休!”)
print(“结束!”)

 

# 输出结果:

循环数据 Baidu
循环数据 谷歌(Google)
自个儿的网站
结束!

注意: i++,++i 在python中不允许行使。

(range函数)

一、假如您要求遍历数字体系,能够动用内置range()函数,它会生成数列。

例:

for i in range(5):
print(i)

# 输出结果:

0
1
2
3
4

二、也能够采纳range钦点区间的值。

例:

for i in range(5,9) :
print(i)

# 输出结果:

5
6
7
8

三、也足以使range以钦定数字起始并点名差别的增量(乃至足以是负数,有的时候那也叫做’步长‘)。

例:

for i in range(0, 10, 3) :
print(i)

# 输出结果:

0
3
6
9

四、您能够组合range()和len()函数以遍历二个队列的目录

例:

>>> a = [‘Google’, ‘Baidu’, ‘frank-me’, ‘Taobao’, ‘QQ’]
>>> for i in range(len(a)):
>>> print(i, a[i])

# 输出结果:

0 Google

1 Baidu

2 frank-me

3 Taobao

4 QQ

五、能够运用range()函数来创设一个列表,用for直接历遍

>>> for i in list(range(5)):

…         print( i )

# 输出结果:

0
1
2
3
4

break和continue语句及循环中的else子句

一、break 语句能够跳出 for 和 while 的循环体。要是您从 for 或 while
循环中甘休,任何对应的循环 else 块将不推行。

例:

for letter in ‘frank-me’: # 第二个实例
    if letter == ‘-‘:           # 当符号为“-”时,跳出
        break
    print (‘当前字符为 :’, letter)

var = 10 # 第三个实例
while var > 0:
    print (‘当期变量值为 :’, var)
    var = var -1
    if var == 5:               # 到数字5(包罗5)时不往下施行
        break

print (“See you!”)

# 输出结果:

脚下字符为 : f
此时此刻字符为 : r
近日字符为 : a
当前字符为 : n
当下字符为 : k
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
See you!

二、continue语句被用来报告Python跳过当前循环块中的剩余语句,然后继续举行下一轮循环。

例:

for letter in ‘frank-me’: # 第一个实例
    if letter == ‘-‘: # 字符为 “-” 时跳过输出,继续往下实践
        continue
    print (‘当前字符 :’, letter)

var = 10 # 第四个实例
while var > 0:
    var = var -1
    if var == 5: # 变量为 5 时跳过输出,继续往下实行
        continue
    print (‘当前变量值 :’, var)
print (“See you!”)

# 输出结果:

近期字符 : f
当前字符 : r
当下字符 : a
脚下字符 : n
此时此刻字符 : k
现阶段字符 : m
眼下字符 : e
澳门凯旋门注册网址,这段时间变量值 : 9
当下变量值 : 8
时下变量值 : 7
现阶段变量值 : 6
近年来变量值 : 4
日前变量值 : 3
脚下变量值 : 2
时下变量值 : 1
现阶段变量值 : 0
See you!

三、循环语句能够有 else 子句,它在穷尽列表(以for循环)或规范成为 false
(以while循环)导致循环终止时被实行,但循环被break终止时不实行。

例:

for i in range(2, 10):
    for x in range(2, i):
        if i % x == 0:
            print(i, ‘=’, x, ‘*’, i//x)
            break
    else:
    # 循环中从未找到成分
    print(i, ‘是质数’)

# 输出结果:

2 是质数
3 是质数
4 = 2 * 2
5 是质数
6 = 2 * 3
7 是质数
8 = 2 * 4
9 = 3 * 3

 

for-else

 

for中绝非break,则else一定会实行

for temp in strs: 

   print(temp)   

else: 

   print(“”)

 

const 修改换量为不可变。

 

(pass语句)

pass是空语句,是为了保证程序结构的完整性。

pass 不做任何事情,一般用做占位语句。

while True:
    pass # 等待键盘中断 (Ctrl+C)

小小的类:

class EmptyClass:
    pass

例:

for letter in ‘frank-me’:
    if letter == ‘-‘:
        pass
    print (‘- 执行 pass’)
print (‘当前字符 :’, letter)

print (“See you!”)

# 输出结果:

这两天字符 : f
脚下字符 : r
时下字符 : a
现阶段字符 : n
近来字符 : k

  • 执行 pass
    当前字符 : –
    当下字符 : m
    脚下字符 : e
    See you!

11.字符串(不可变)

一、创建
       ‘ str ’,“ str ”单引号或双引号包裹起来的内容
       顺序,序列
           — 偏移量,索引,直标
       长度
           –len()重回贰个行列的长度
       ** 单个字符,即长度为1的字符串

二、索引
       test_str[0]
       ** 极其的:最终一成分的目录“-1”,“-2”代表尾数第二,就那样类推
       切片
           — test_str[strat:end]
           — start:起头索引(包蕴这几个因素)
           — end:截至索引(不分包这一个成分)
           — start < end
       不可变
           — 无法修改

切片例:

str = “dasfaf”

str[2:4] #(取得2到3的), 

str[2:]  #(到最后), 

str[2:-1:2] #(步长2,隔多个取七个)

逆序:

str = “abcdefABCDEF” 

str[0:]  # out:”abcdefABCDEF” (顺序)

str[-1:]  # out:”F” (尾数第三个)

str[-1:0]  # out:”” 

str[-1:0:-1]  # out:”FEDChina Basketball Associationfedcb” (逆序,不含第三个)

str[-1::-1], str[::-1]  # out:”FEDCBAfedcba”(逆序

 

三、字符串连接:

a = b + c  #或者

a = “===%s===”%(b+c)  #或者

a = “==={}===”.format(b+c)

四、常见操作

find: str.find(“abc”)  #
从左向右有重临第八个相称字符串的发轫下标,未有回来-1。rfind():从右向左。 

str.index(“abc”)  #找到再次来到伊始下标,未有抛出非常。 存在rindex(). 

str.count(“abc”)  #协作的个数。

 

str.replace(“abc”, “def”)  #同java,把右边手的替换来右侧的 。

str.replace(“abc”, “def”,1)  #其三个参数是从左到右替换个数。 

 

str.split(” “)  #同java
,通过点名分隔符(包罗空格、换行(\n)、制表符(\t)等)对字符串实行切开,倘诺参数
num 有钦命

          值,则仅相隔 num 个子字符串。

str.capitalize()  #字符串的首先个字母大写。 

str.title()  #字符串的种种单词的首字母大写。 

str.startswith(“abc”), str.endswith(“abc”)
 #同java,用于检查字符串是还是不是是以钦命子字符串起头,假若是则赶回 True,

                            不然赶回 False。假诺参数
beg 和 end 钦赐值,则在钦点范围内检查。

str.lower() str.uper()  #全部的字母小写和题诗。 

str.center(50)  #从中显示,行总厅长50 ”     abc     “

str.ljust(50), str.rjust(50)  #左(右)对齐

 

str.lstrip()  #剔除左侧空格

str.rstrip()  #右侧空格

str.strip()  #删去两端空格.

12.列表 (类似数组,可变,针对自个儿的变化)

运算符

表达式

结果

描述

len([1, 2, 3])

3

算算成分个数

[1, 2, 3] + [4, 5, 6]

[1, 2, 3, 4, 5, 6]

连接

[‘Hi!’] * 4

[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]

复制

3 in [1, 2, 3]

True

要素是还是不是留存

for x in [1, 2, 3]: print(x, end=” “)

1 2 3

迭代

创建
    序列
    list1 = [1,2,3,4,5,6]

例:

[“zhangsan”,”lisi”]

#定义

names = [“zhangsan”, “lisi”, 3.14] 
#列表中的数据足以是见仁见智的数据类型。  能够下标,和切成块。

增加和删除改查

   
    — 1.list.append(item)向尾巴部分增多
    — 2.list.insert(index,item) 向钦点的地点插入

例:#增

names.append(“abc”) #–>插入到最终; 

names.insert(0, “bcc”) #–>插入钦赐地点。 

names = names1 + names2 #七个列表用连接符

names1.extend(names2) #扩充

#注意:append增添的因素;extend连接的列表

   
    — list.pop(index)  #–>index 暗许-1 (最终壹个)

例:#删

names.pop() #–>删除最终两个; 

names.remove(“lisi”) #–>依照剧情剔除; 

del names[0] #–>下标删除

   

    — 直接复制

例:#改

names[0] = “abc” 

   
    索引
    操作同字符串

例:#查

name[1:] # “lisi”

in, not in #是不是留存 (if “zhangsan” in names:) 

#能够for… in 循环遍历

len(names) #要素个数 

 

13.字典(可变)

a = {“name”:”yy”, “age”: 12}

 

a[“name”] = “yy” #python2 = 凯旋门074网址assic =  不支持中文。直接写key-value 

del a[“name”]

a[“name”] = “zz” #一致key的值覆盖。

a[“name”], a.get(“name”)

例:

>>> params = {“server”:”mpilgrim”, “database”:”master”,
“uid”:”sa”, “pwd”:”secret”}
>>> params
{‘server’: ‘mpilgrim’, ‘database’: ‘master’, ‘uid’: ‘sa’, ‘pwd’:
‘secret’}

>>> [“%s=%s” % (k, v) for k, v in params.items()]
[‘server=mpilgrim’, ‘database=master’, ‘uid=sa’, ‘pwd=secret’]

>>> “;”.join([“%s=%s” % (k, v) for k, v in params.items()])
‘server=mpilgrim;database=master;uid=sa;pwd=secret’

 

 
字典常见操作

len(params) #键值对的个数

 

params.keys() 或 dict.keys(params) #返回key的列表

if “uid” in params.keys(): #认清是或不是留存某些key

    print(“yes”)

params.values() #返回value的列表

 

14.元组(类似列表,不可变)

列表能够增加和删除改,元组不能够改

tup1 = (); #空元组

例:

>>> tup1 = (50)

>>> type(tup1)     # 不加逗号,类型为整型

# 施行结果:

<class ‘int’>

 

>>> tup1 = (50,)

>>> type(tup1)     # 加上逗号,类型为元组

# 施行结果:

<class ‘tuple’>

 

访问:

例:

tup1 = (‘Google’, ‘Baidu’, 1997, 2000)

tup2 = (1, 2, 3, 4, 5, 6, 7 )

 

print (“tup1[0]: “,tup1[0])

#python2 = 凯旋门074网址assic =  不支持中文。 实行结果:

tup1[0]:  Google

 

print (“tup2[1:5]: “, tup2[1:5])

# 推行结果:

tup2[1:5]:  (2, 3, 4, 5)

 

修改:

例:

tup1 = (12, 34.56);

tup2 = (‘abc’, ‘xyz’)

 

# 以下修改元组成分操作是不法的。

# tup1[0] = 100

 

# 创建二个新的元组

python2 = 凯旋门074网址assic =  不支持中文。tup3 = tup1 + tup2;

print (tup3) #(12, 34.56, ‘abc’, ‘xyz’)

 

删除

tup = (‘Google’, ‘Baidu’, 1997, 2000)

 

print (tup)

del tup;

 

仿佛拆包

a = (11,12)

b = a

b #out (11,12)

c,d = a #类似拆包

c #out 11

d #out 12

 

例:

info = {“name”:”ysw”, “age”:24}

for temp in info:

    print(temp)

# 实行结果:

name

 age

 

for temp in info.items():

    print(“key=%s,value=%s”%(temp[0],temp[1]))

#or(或者)

for a,b in info.items():

    print(“key=%s,value=%s”%(a,b))

# 实行结果

key=name,value=ysw
key=age,value=24

 

遍历本领

一、在字典中遍历时,关键字和相应的值能够接纳 items()
方法同期解读出来

knights = {‘gallahad’: ‘the pure’, ‘robin’: ‘the brave’}

for k, v in knights.items():

          print(k, v)

 

# 执行结果:

gallahad the pure

robin the brave

 

二、在类别中遍历时,索引地方和对应值能够应用 enumerate()
函数同期获得

>>> for i, v in enumerate([‘tic’, ‘tac’, ‘toe’]):

…     print(i, v)

 

# 执行结果:

0 tic

1 tac

2 toe

 

三、同偶然候遍历五个或更加多的系列,能够选择 zip() 组合

>>> questions = [‘name’, ‘quest’, ‘favorite color’]

>>> answers = [‘lancelot’, ‘the holy grail’, ‘blue’]

>>> for q, a in zip(questions, answers):

…     print(‘What is your {0}?  It is {1}.’.format(q, a))

# 实行结果:

What is your name?  It is lancelot.

What is your quest?  It is the holy grail.

What is your favorite color?  It is blue.

 

四、要反向遍历二个队列,首先钦定那么些队列,然后调用 reversed() 函数

>>> for i in reversed(range(1, 10, 2)):

…     print(i)

# 实施结果:

9

7

5

3

1

 

五、要按顺序遍历贰个队列,使用 sorted()
函数再次来到七个已排序的类别,并不修改原值

>>> basket = [‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’,
‘banana’]

>>> for f in sorted(set(basket)):

…     print(f)

# 实践结果:

apple

banana

orange

pear

 

15.函数

def abc():

    print(“”)

 

abc()

#注意: 函数的定义要求在函数的调用以前,不然报错。

可改换与不足改变对象: 
在python中,strings,tuples和numbers是不足改造对象,list.dict等则是可退换对象。 

  • 不行变类型:变量赋值 a=5后在赋值a=10,生成了新的指标,原对象遗弃。 
  • 可变类型:变量赋值 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 printinfo( name, age = 35 ):

   “打字与印刷任何传入的字符串”

   print (“名字: “, name);

   print (“年龄: “, age);

   return;

 

printinfo( age=50, name=”baidu” );

print (“————————“)

printinfo( name=”baidu” );

 

 # 实践结果:

名字:  baidu

年龄:  50


名字:  baidu

年龄:  35

 

二、可变参数

例:

def printinfo( *vartuple ):

   “打字与印刷任何传入的参数”

   print (“输出: “)

   for var in vartuple:

      print (var)

   return;

 

printinfo(10,32,22)

 

#无名氏函数(lambda创造佚名函数)

 

sum = lambda arg1, arg2: arg1 + arg2;

 

print (“相加后的值为 : “, sum( 10, 20 ))

print (“相加后的值为 : “, sum( 20, 20 ))

 

# 试行结果:

输出:
10
32
22
相加后的值为 : 30
相加后的值为 : 40

 

三、global关键字修改外界作用域变量

例:

num = 1

def fun1():

    global num  # 要求选用 global 关键字申明

    print(num)

    num = 123

    print(num)

fun1()

#  实行结果:

1

123

 

四、nonlocal 修改嵌套作用域变量

例:

def outer():

    num = 10

    def inner():

        nonlocal num   # nonlocal关键字注解

        num = 100

        print(num)

    inner()

    print(num)

outer()

 

# 试行结果:

100

100

 

16.迭代器和生成器

一、字符串,列表和元组对象都可用以成立迭代器。

例:

list = [1,2,3,4]

it = iter(list)

print(next(it)) 

print(next(it)) 

 

#施行结果

1

2

 

for x in it:  #遍历

    print(x, end = “”)

#施行结果:

1 2 3 4

 

 例:

import sys

list = [1,2,3,4]

it = iter(list)

while True:

    try:

        print(next(it))

    except StopIteration:

        sys.exit()

# 实行结果:

1

2

3

4

 

二、生成器(TODO) 

yield 的函数,生成器是回去迭代器的函数,只可以用来迭代操作。

例:

import sys

 

def fibonacci(n): # 生成器函数 – 斐波那契

    a, b, counter = 0, 1, 0

    while True:

        if (counter > n):

            return

        yield a               # 相当于generator的print(a)

        a, b = b, a + b   # 注意,赋值语句也等于:t = (b,a+b), t
是一个tuple,a = t[0] , b = t[1]

        counter += 1

f = fibonacci(10) # f 是一个迭代器,由生成器重返生成

 

while True:

    try:

        print (next(f), end=” “)

    except StopIteration:

        sys.exit()

 

#施行结果:

0 1 1 2 3 5 8 13 21 34 55

 

17.模块

 Python
提供了三个方法,把一些定义存放在文书中,为局地剧本大概交互式的解释器实例使用,那几个文件被称作模块。 

  • import语句,想行使 Python 源文件,只需在另二个源文件里推行 import
    语句。

例:

#!/usr/bin/python3

# Filename: support.py

 

def print_func( par ):

    print (“Hello : “, par)

    return

 

#!/usr/bin/python3

# Filename: test.py

 

 

import support #导入模块,即文件名

 

# 今后可以调用模块里带有的函数了

support.print_func()

 

from…import语句,从模块中程导弹入三个钦命的部分到近期命名空间中。

#导入模块 fibo 的 fib 函数

from fibo import fib, fib2

>>> fib(500)

  • From…import* 语句,把八个模块的有着剧情全都导入到当前的命名空间。
  • 模块除了艺术定义,还能包蕴可实行的代码。那些代码一般用来开始化这么些模块。那些代码只有在率先次被导入时才会被试行。
  • name品质,四个模块被另三个顺序第4回引进时,其主程序将运转。假设大家想在模块被引进时,模块中的某一程序块不实行,能够用name属性。

例:

#!/usr/bin/python3

# Filename: using_name.py

 

if __name__ == ‘__main__’:

   print(‘程序自个儿在运维’)

else:

   print(‘笔者来自另一模块’)

 

#实践结果:

先后本人在运维

 

  • Python 会依据 sys.path 中的目录来探索那些包中蕴涵的子目录。
  • 目录唯有包罗三个叫做 init.py
    的文书才会被认作是一个包,首假诺为着防止某个滥俗的名字(比方叫做
    string)不当心的震慑搜索路线中的有效模块。
  • 推荐:from Package import specific_submodule

18.文件

open()方法再次回到文件,第3个参数为文件张开药格局。暗许只读r / 写w,a追加…

f = open(“/tmp/test.txt”,”w”)

 

f.write(“人生苦短,小编用python!”)

 

f.close()

  • f.read(size) 读取文件内容,size为空或负数则全体重回。
  • f.readline() 会从文件中读取单独的一条龙。换行符为 ‘\n’。f.readline()
    若是回去二个空字符串, 表达已经已经读取到最后一行。
  • f.readlines() 读取文件全体行,并以列表重临。
  • f.write(string) 将 string 写入到文件中,
    然后回到写入的字符数。如若要写入一些不是字符串的事物,
    那么将索要先进行调换。

19.类

类方法

例:

class MyClass:

    i = 12345

   
#类措施必须有叁个万分的第三个参数,惯例是self,不固定;代表的的类的实例而非类

    def f(self):

        return “hello world”

 

x = MyClass()

print(“MyClass 类的性质 i 为:”, x.i)

print(“MyClass 类的艺术 f 输出为:”, x.f())

 

#施行结果:

MyClass 类的属性 i 为: 12345
MyClass 类的主意 f 输出为: hello world

 

构造方法

例:

class Complex:

    #构造方法

    def __init__(self, realpart, imagpart):

        self.r = realpart

        self.i = imagpart

x = Complex(3.0, -4.5)

print(x.r, x.i)  

 

# 施行结果:

3.0 -4.5

 

例: 

类定义

class people:

    #概念基性子能

    name = ”

    age = 0

    #概念私有属性,私有属性在类外界不大概直接开始展览走访

    __weight = 0

#概念构造方法

    def __init__(self,n,a,w):

        self.name = n

        self.age = a

        self.__weight = w

    def speak(self):

        print(“%s 说: 我 %d 岁。” %(self.name,self.age))

 

# 实例化类

p = people(‘baidu’,10,30)

p.speak()

 

 # 推行结果:

baidu 说: 我 10 岁。

 

继承

例:

类定义

class people:

    #概念基天本性

    name = ”

    age = 0

    #概念私有属性,私有属性在类外界不能够直接开展走访

    __weight = 0

    #概念构造方法

    def __init__(self,n,a,w):

        self.name = n

        self.age = a

        self.__weight = w

    def speak(self):

        print(“%s 说: 我 %d 岁。” %(self.name,self.age))

 

#单承接示例

class student(people):

    grade = ”

    def __init__(self,n,a,w,g):

        #调用父类的构函

        people.__init__(self,n,a,w)

        self.grade = g

    #覆写父类的不二等秘书籍

    def speak(self):

        print(“%s 说: 我 %d 岁了,我在读 %d
年级”%(self.name,self.age,self.grade))

 

#另八个类,多种承接以前的预备

class speaker():

    topic = ”

    name = ”

    def __init__(self,n,t):

        self.name = n

        self.topic = t

    def speak(self):

        print(“我叫 %s,小编是二个解说家,小编发言的主旨是
%s”%(self.name,self.topic))

 

#多种承袭

class sample(speaker,student):

    a =”

    def __init__(self,n,a,w,g,t):

        student.__init__(self,n,a,w,g)

        speaker.__init__(self,n,t)

 

test = sample(“frank”,25,80,4,”Python”)

test.speak()   #措施名同,默许调用的是在括号中排前地父类的格局

 

# 试行结果:

自个儿叫 frank,小编是八个演讲家,作者发言的核心是 Python

 

20.正则表明式

      re.match与re.search的区别 
     
re.match只相配字符串的开头,如若字符串发轫不合乎正则表明式,则相配失利,函数重临None;而re.search匹配整个字符串,直到找到二个相配。

例:

import re

 

line = “Cats are smarter than dogs”;

matchObj = re.match( r’dogs’, line, re.M|re.I)

if matchObj:

   print (“match –> matchObj.group() : “, matchObj.group())

else:

   print (“No match!!”)

 #实施结果

   No match!!

 

例:

import re

 

line = “Cats are smarter than dogs”;

matchObj = re.search( r’dogs’, line, re.M|re.I)

if matchObj:

   print (“search –> matchObj.group() : “, matchObj.group())

else:

   print (“No match!!”)

 #施行结果

   search –> matchObj.group() :  dogs

 

搜索和替换

例:

import re

phone = “2018-666-666 # 那是贰个电话号码” 

num = re.sub(r’#.*$’, “”, phone)   # 删除“#”后边的讲解内容

print (“电话号码 : “, num)

 

#实施结果

电话号码 :  2018-666-666 

 

例:

import re

phone = “2018-666-666 # 那是贰个电话号码” 

num = re.sub(r’\D’, “”, phone) # 移除非数字的开始和结果

print (“电话号码 : “, num)

 

#实施结果

电话号码 :  2018666666

 

最后用一张图来归纳:

凯旋门074网址 2

相关文章