快捷搜索:
来自 计算机编程 2019-09-23 04:39 的文章
当前位置: 67677新澳门手机版 > 计算机编程 > 正文

python基础语法

1.注释

Python学习网站推荐

单行:# 
多行:三个'单引号'或三个"双引号"

https://www.bilibili.com/video/av10840922/?from=search&seid=7483086631377314787

'''

安装教程

print("hello world") 

https://www.python.org/downloads/windows/   官网

'''

http://www.geany.org/Download/Releases

程序好习惯编辑器,用这个不如用pycharm社区免费版

"""

针对geany上有汉字报错的情况,请在每次编程时在程序第一行打上#coding=gbk

print("hello world") 

或在程序第一行打上# -*- coding: UTF-8 -*-

"""

http://www.pygame.org/news  Pygame  

2.编码

安装python正式版本后,打开CMD,输入pip install pygame就可安装pygame

python2 = assic =  不支持中文

http://www.runoob.com/      菜鸟教程

文件中有中文,不管是否为注释,python2执行报错。 

https://www.bilibili.com/video/av9784617/?from=search&seid=6723760175629363784#page=51                          爬虫教程(大学教授)

解决:程序首行加 #coding=utf-8 或 #*-* coding:utf-8 *-*

http://www.runoob.com/python3/python3-tutorial.html 教程,注意选python3,别选成2了

python3 = unicode = 默认支持中文

https://www.jetbrains.com/pycharm/download/#section=windows       Pycharm官网,其中Professional是收费的,功能更多

3.模块:

Community 是免费的,功能也非常强大,它能帮你找出你发现不了的语法错误(很关键)

在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。

http://www.jb51.net/list/list_97_1.htm    学习网站

为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含的代码就相对较少,很多编程语言都采用这种组织代码的方式。在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

python2中input的内容当做执行的内容,python3当做字符串。如a = input(“”). python2中的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 #(除法)

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否则:

图片 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:"FEDCBAfedcb" (逆序,不含第一个)

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" #直接写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])

# 执行结果:

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

 

# 创建一个新的元组

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属性,一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,可以用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()方法返回文件,第二个参数为文件打开方式。默认只读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

 

最后用一张图来概括:

图片 2

Python的核心!Python PEP 8建议每级缩进都使用四个空格,这既可提高可读性,又留下了足够的多级缩进空间。在字处理文档中,大家常常使用制表符而不是空格来缩进。对于文字处理文档来说,这样做的效果很好,但混合使用制表符和空格会让Python解释器感到迷惑。每款文本编辑器都提供了一种设置,可将输入的制表符转换为指定数量的空格。你在编写代码时应该使用制表符键,但一定要对编辑器进行设置,使其在文档中插入空格而不是制表符。在程序中混合使用制表符和空格可能导致极难解决的问题。如果你混合使用了制表符和空格,可将文件中所有的制表符转换为空格,大多数编辑器都提供了这样的功能。(可以不看,缩进就是Tab键)

缩进错误会出现如下报错:

IndentationError: unexpected indent 错误是 python 编译器是在告诉你"Hi,老兄,你的文件里格式不对了,可能是tab和空格没对齐的问题",所有 python 对格式要求非常严格。

如果是 IndentationError: unindent does not match any outer indentation level错误表明,你使用的缩进方式不一致,有的是 tab 键缩进,有的是空格缩进,改为一致即可。

因此,在 Python 的代码块中必须使用相同数目的行首缩进空格数。

建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用。

 

空行:

函数之间或‘类’的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。

空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。

记住:空行也是程序代码的一部分。

 

python保留字:

保留字即关键字,我们不能把它们用作任何标识符或变量名称。Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字:

>>> import keyword

>>> keyword.kwlist

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

 

多行语句:

Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠()来实现多行语句,例如:total = 'item_one'

               'item_two'

                'item_three'

 

在 [], {}, 或 () 中的多行语句,不需要使用反斜杠(),例如:

total =['item_one',  ‘item_two’, ‘item_three’

               'item_four',  'item_five' ]

本文由67677新澳门手机版发布于计算机编程,转载请注明出处:python基础语法

关键词: