Python基础

Python语法

注释

注释的三种方式如下：

1
2
3
4
5
6
7
8
9
# 注释

'''
注释
'''

"""
这也是注释
"""

缩进

python不需要 {} 都是使用缩进表示代码块

字符串

字符串可以 ‘ ‘， “ “, “”” “””

1
2
3
4
5
6
'字符串'
"字符串"
"""
多行
字符串
"""

空行

函数之间或类方法之间用空行分开

; 符号

同一行可以显示多条语句，使用 ; 隔开

导入

  • 在 python 用 import 或者 from…import 来导入相应的模块

  • 将整个模块(somemodule)导入，格式为： import somemodule

  • 从某个模块中导入某个函数,格式为： from somemodule import somefunction

  • 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

  • 将某个模块中的全部函数导入，格式为： from somemodule import *

end关键字

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

1
2
3
while b < 1000:
    print(b, end=',')
    b += 1

条件控制

1
2
3
4
5
6
7
8
9
10
11
12
if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

循环

while循环:

1
2
3
4
5
6
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")

for循环：

1
2
3
4
5
6
7
8
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")

注意：以上循环中，else为跳出循环后执行的逻辑，且只执行一次，可以不存在else

range()函数：

1
2
3
4
5
for i in range(103) :
    print(i)

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

参数最多可以有三个，第一个为开始限定，第二个为结束限定，第三个为步长

1
2
3
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
    print(i, a[i])

break、continue

  • break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行

  • continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环

pass 语句：

1
2
while True:
    pass

遍历技巧：

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

1
2
3
4
5
6
7
for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

# 结果
0 tic
1 tac
2 toe

反向遍历：

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

迭代器

迭代器有两个基本的方法：iter( 和 next()

字符串，列表或元组对象都可用于创建迭代器

示例：

1
2
3
4
5
6
7
8
9
10
11
12
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

函数

1.语法

1
2
def 函数名（参数列表）:
    函数体

可更改(mutable)与不可更改(immutable)对象：

  • 不可变类型：变量赋值 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也会受影响

2.参数

必需参数： 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样，既只要声明了参数，调用时就必须传递

关键字参数：使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

例如：

1
2
3
4
5
6
7
def printme( name, age ):
    "打印任何传入的字符串"
    print (str)
    return

#调用printme函数
printme( age = 10, name = "菜鸟教程")

默认参数：调用函数时，如果没有传递参数，则会使用默认参数,与Kotlin一样

不定长参数：就是可变参数，python的可变参数可以有多种类型，任意指定

例如：

1
2
3
4
5
6
7
8
9
# 可写函数说明
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vardict)

# 调用printinfo 函数
printinfo(1, a=2,b=3)

3.匿名函数

语法：lambda [arg1 [,arg2,…..argn]]:expression

示例：

1
2
3
4
5
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))

4.return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式，不带参数值的return语句返回None

示例：

1
2
3
4
5
6
7
def sum( arg1, arg2 ):
total = arg1 + arg2
print ("函数内 : ", total)
return total

# 调用sum函数
total = sum( 10, 20 )

变量作用域

1.Python的作用域一共有4种

  • L： （Local） 局部作用域

  • E： （Enclosing） 闭包函数外的函数中

  • G： （Global） 全局作用域

  • B： （Built-in） 内置作用域（内置函数所在模块的范围）

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

示例：

1
2
3
4
5
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

全局变量和局部变量，与Java类似

2.global 和 nonlocal 关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字:

示例：

1
2
3
4
5
6
7
8
9
10
11
num = 1 # 外部作用域定义变量

def fun1():
    global num  # 需要使用 global 关键字声明
    print(num)  # 注意这两想要打印成功，一方面可思议使用global关键字，如果不适用此关键词声明，可以将num放在方法中传递进来使用，否则将会报错，这里跟Java不同，这是因为 fun1 函数中的 num 使用的是局部，未定义，无法修改。
    num = 123
    print(num)

fun1()  # 输出:  1    123

print(num) # 输出： 123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字:

示例：

1
2
3
4
5
6
7
8
9
def outer():
    num = 10  # 嵌套作用域
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num) 
    inner()
    print(num)
outer() 输出 100  100

模块和包

1.模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能，这也是使用 python 标准库的方法

import 语句

想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

import module1, module2,... moduleN

from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1, name2, ... nameN

from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称，以一个字符串列表的形式返回

2.包

包是一种管理 Python 模块命名空间的形式，采用”点模块名称”

比如一个模块的名称是 A.B， 那么他表示一个包 A 中的子模块 B

用户可以每次只导入一个包里面的特定模块，比如:

1
2
3
import sound.effects.echo
这将会导入子模块:sound.effects.echo    它必须使用全名去访问:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还有一种导入子模块的方法是:

1
2
3
from sound.effects import echo
这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:
echo.echofilter(input, output, delay=0.7, atten=4)

还有一种变化就是直接导入一个函数或者变量:

1
2
3
from sound.effects.echo import echofilter
同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:
echofilter(input, output, delay=0.7, atten=4)

基本数据类型

变量不需要声明，直接赋值，且赋值后才能使用

1
2
3
4
counter = 1000
name = "wangjia"

a = b = c = 100

python基本类型

  • Number（数字）

  • String（字符串）

  • Tuple（元组）

  • List（列表）

  • Set（集合）

  • Dictionary（字典）

注意：前三类是不可变类型

1.python数字类型 Number

int、bool、float、complex（复数）

可以删除对象引用 del var, (del var_a, var_b)

有很多数学函数可以直接调用，比如Java中Math函数中的很多计算函数，在python中直接用就可以，例如 ：abs(-1)，还有一些随机数函数，用的时候查就可以

2.字符串

python中没有字符类型，单个字符当做字符串处理

字符串截取：变量[头下标:尾下标] 支持负数，负数代表从后往前截取

使用 “/“ 转义特殊字符，可以在字符串前加 “r” 表示原始字符，例如 r”abc/nvc”

注意字符串格式化：

一般用于日志输出，print (“我叫 %s 今年 %d 岁!” % (‘小明’, 10))

注意字符串中有四十多个功能内建函数，我们在操作判断关于字符串时查看以后函数是否支持

3.list 列表

可以直接初始化: list = [‘12321’, 299, 12.80]

也支持截取，截取方法特性与字符串一样

list是可变的，可以更改元素，list[0] = ‘45654’, 或者批量修改：list[1:3] = [‘45654’, 300, 11.20]

删除元素：list[0] = [], list[0:2] = []

合并列表，直接 + ，例如： list1 + list2。 list * 2 表示列表元素复制两倍

列表函数：

1
2
3
4
5
6
7
8
1. 获取长度函数：len(list)
2. max(list)：返回列表元素最大值
3. min(list)：返回列表元素最小值
4. ist(seq)：将元组转换为列表
5. list.append(obj)：在列表末尾添加新的对象
6. list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
7. list.insert(index, obj)：将对象插入列表
8. list.remove(obj)：移除列表中某个值的第一个匹配项

del可以根据索引来删除列表元素，例如： del list[2:4]

可以使用append和pop方法将列表作为堆栈使用，等等

4.tuple元组

与list类似，但是元素不可变，也支持截取输出

tuple不可变，但是可以包含可变的对象，或list

创建空元组：tup1 = ();

元组不可以修改，但是可组合： tup3 = tup1 + tup2

元组元素不能删除，可以删除整个元组： del tup1

元组运算符支持与list一致

内置函数有：len、max、min、tuple

5.set集合

创建方式： set = {1, 2, 3, 4} 或者，set(1) 创建空set 必须使用 set = set()

可以使用 in 关键字判断元素在不在set中， 例如 bool = 2 in set

set支持运算，- 表示差集， | 表示并集， & 交集， ^ 不同时存在的元素

基本内置函数：

1
2
3
4
1. 添加元素：set.add(元素)
2. 删除元素：set.remove( x )
3. 计算元素个数：len(s)
4. 清空集合：s.clear()

6.Dictionary字典

列表是有序的对象集合，字典是无序的对象集合,字典当中的元素是通过键来存取的，类似于map

使用： dict = {} dict[“jjw”] = “wangjia”

字典键不能重复，值无所谓

可以这样创建：d = {key1 : value1, key2 : value2 }

使用字典取值的时候： dict[key] 如果key不存在于字典中，就会抛出异常

字典修改与 Kotlin修改map值一样

删除元素： del dict[key]

字典的键必须是不可变的，不可以使用列表作为键

基本内置函数：

1
2
3
4
5
6
7
1. len(dict)：计算字典元素个数，即键的总数
2. str(dict)：输出字典，以可打印的字符串表示，类似于toString()
3. radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
4. key in dict：如果键在字典dict里返回true，否则返回false
5. radiansdict.items()：以列表返回可遍历的(键, 值) 元组数组
6. radiansdict.keys()：返回一个迭代器，可以使用 list() 来转换为列表
7. radiansdict.values()：返回一个迭代器，可以使用 list() 来转换为列表

遍历字典技巧：

1
2
3
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

7.数据转换

方法：数据类型(数据) 即可。 例如 ： float(“10.00”)

Python运算符

数值运算符

数值运算可以直接运算，运算的结果是精确的 (+、-、、/、%、*、\)

主要说明：其他运算符于Java一致， /是精确除法，与Java不一样 ** 是幂，返回x的y次幂 // 取整除,向下取接近除数的整数 类似于我们Java中的 “"

注意以上运算符都支持赋值运算，例如： += 、 *=、 //=

类型判断

内置的 type() 函数可以用来查询变量所指的对象类型， isinstance()会判断类型是否属于某种类型

位运算

与Java一致

逻辑运算符

例如：a = 10; b = 20;

and： x and y: 布尔”与” - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20

or x or y: 布尔”或” - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10

not not x: 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False

成员运算符

in 如果在指定的序列中找到值返回 True，否则返回 False

not in 如果在指定的序列中没有找到值返回 True，否则返回 False

一般用来判断变量在不在集合中，或者指定字符串中包含不包含特定字符串

身份运算符

is: 是判断两个标识符是不是引用自一个对象

is not: 是判断两个标识符是不是引用自不同对象

例如：a = 10; b = 20; a is b 返回结果 true

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等

错误和异常

异常

即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常，异常的类型有多种，与Java类似

异常处理，使用类似于try-catch语句捕获处理：

1
2
3
4
5
6
7
8
for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)   # 处理异常
    else:   # else语句表示没有发生任何异常的时候执行的代码块
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

except就类似于catch，except可以处理多个异常：

1
2
except (RuntimeError, TypeError, NameError):
        pass

抛出异常

Python 使用 raise 语句抛出一个指定的异常，示例：

1
raise NameError('HiThere')

定义清理行为

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为，就是finally代码块，具体执行与Java类似：

1
2
3
4
5
6
7
8
9
def divide(x, y):
    try:
        result = x / y
    except ZeroDivisionError:
        print("division by zero!")
    else:
        print("result is", result)
    finally:
        print("executing finally clause")

最后更新： 2019年07月24日 17:40

原始链接： https://jjw-story.github.io/2019/07/20/Python/

赏
× 请我吃糖~
打赏二维码