title： Python基础

[toc]

基础语法

Python 中的程序是自上而下，从没有缩进的代码开始执行的，只有处于调试状态下才可以设置断点

第一个 python 程序：

1
print("Hello World")

type 用于查看指定数值或变量类型：

1
print(type(10), 10)

在 python3 中，所有的整数都是 int 类型，可以表示的范围是无限的

字符串类型：str

进制转换：

1
2
print(hex(100), oct(100))   #将十进制数转换成不同进制的数
print(int("64", 16))		#将字符串对应的指定进制数转换成十进制

双引号可直接包含单引号，单引号也可直接包含双引号

三引号可用于保留字符串原有格式，三个单引号使用最多的就是多行注释

1
2
3
4
5
6
7
print("this is string \"1\"")
print("this is string '2'")
print('this is string "3"')
print("""this is 
	string""")
print('''this is 
	string''')

python 中的布尔类型首字母大写：

1
print(type(True), type(False))

python 是一个弱类型语言，即在程序运行过程中变量的类型可能是变化的，故指明变量类型无意义

1
2
3
4
n = 100
print(type(n), n)
n = 1.1
print(type(n), n)

每个变量都有一个对应的引用计数，当一个变量的引用计数为0，变量就会被销毁

1
2
3
4
5
6
7
import sys						#类似导入头文件
s = "123"
print(sys.getrefcount("123"))	#求引用计数
s1 = s							#变量的赋值
print(sys.getrefcount("123"))
del s1							#类似于释放空间
print(sys.getrefcount("123"))

输入输出：

python3 中使用 input 进行输入，返回值是 str 类型的数据，可以通过 eval 将输入的内容自动转换成和输入对应的类型

1
2
3
4
5
n = input("please input a number:")
print(type(n), n)

n = eval(input("please input a number:"))
print(type(n), n)

输出主要使用 print 函数，此函数可以接收不定个数的参数并且能够格式化输出

1
2
3
4
5
#方式一：使用 % 进行格式化输出
print("%d * %d == %d" % (10, 10, 10*10))
#方式二（推荐）：使用 format 进行格式化输出
print("{0} * {0} == {1}".format(10, 10*10))
print("{1:6.2f} {0} {0}".format(10, 30))

python 中的运算符幂【**】

1
print(100**100)

python 中的运算符除法：保留小数【/】和截断除法【//】

1
2
print(2 / 3)
print(2 // 3)	#整除

python 中的运算符值相等【==】和地址相等【is】

1
2
3
4
5
6
7
l1 = [1, 2, 3]
l2 = l1			#浅拷贝，值相等，地址相等
print(l1 == l2, l1 is l2)
l3 = l1.copy()	#深拷贝，值相等，地址不等
print(l1 == l3, l1 is l3)
#输出变量的地址
print(hex(id(l1)), hex(id(l2)), hex(id(l3)))

python 中的运算符判断某一个元素是不是指定序列的成员【in】

1
2
print('a' in 'abc')
print("1" in "324")

一些常见表达式的结果值：对于数值类型，非空就是真，对于序列类型（字符串、列表），没保存东西就是假

三大结构

选择结构

python 只有 if else，没有 switch case

if 后紧跟一个表达式，不需要加括号，每一条 if 或 else 或 elif 后必须要加冒号，紧接着的下一行必须要缩进，同一级别的缩进会被视作一个语句块

1
2
3
4
5
n = eval(input("please input a number:"))
if n % 2 == 1:
    print("这是一个奇数")
else:
    print("这是一个偶数")

循环结构

  1. while 的使用方式和 C/C++ 相同

  2. for 的使用方式类似于 for xxx in 可迭代序列

    xxx 表示可迭代序列中的第 n 个元素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    for i in range(100):
        print(i, end = "-")
    print()

    l = list("123456789")
    #方式一，使用for循环遍历列表，值：
    for i in l:
        print(i, end = " ")
    print()
    #方式二，索引：
    for i in range(len(l)):		#生成0~len间的索引
        print(l[i], end = " ")
    print()
    #方式三，枚举，生成键值对：
    for index, item in enumerate(l):	
        print(index, item, end = "	")
    print()

    for 中可以使用 break 和 continue，和 C 语言没区别

    for 搭配 break 和 else 可以生成一个新语法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    #迭代10到20间的数
    for num in range(10, 20):
        #根据因子迭代
        for i in range(2, num):
            #判断能否被2~num间整除
            if num % i == 0:
                j = num / i
                print("%d = %d * %d" % (num, i, j))
                break
        else:
            print(num, "是一个素数")

    使用列表生成式生成有一定规则的列表：

    1
    2
    3
    # [变量 for 变量 in 序列 if 条件]
    l = [i for i in range(100) if i % 8 == 0]
    print(l)

    遍历字典的方式，三种依赖三个函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    d = {1:1, 2.2:2, "3":3, (4,):4}
    #方式一，直接遍历值：
    for value in d.values():
        print(value, end = " ")
    print()
    #方式二，通过键获取：
    for key in d.keys():
        print(d[key], end = " ")
    print()
    #方式三，获取键值对：
    for key, value in d.items():
        print(key, value, end = "    ")
    print()

基本类型

可变类型：set list dict

不可变类型：int float bool string tuple

列表 [list]

只要以 [] 包含，就会被认为是一个列表，列表中可以保存不同类型的数据，列表的设置和访问和数组是相同的，列表中可以包含列表

1
2
3
4
5
6
l = [1, "2", 3.3, False]
print(l)
print(type(l))
print(l[0], l[3])
l[0] = [1, 2, 3, 4]
print(l, l[0][3])

列表的方法（成员函数）和函数（全局函数）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
#计算长度，可以用于所有的序列中，包括str，可以使用count方法
print(len(l))
#拼接，可以使用extend方法
print([1, 2, 3] + [4, 5, 6])
#重复
print([1, 2, 3] * 10)
#比较
print([1, 2, 3] is [1, 2, 3])	#地址不同
print([1, 2, 3] == [1, 2, 3])	#值相同
#最大值
print(max([1, 2, 4, 9, 5, 3, 7]))
#字符串转列表
print(list("12345"))
#添加数据到列表的结尾
l.append(0)
l.append("dfsfd")
#查找，传入值返回下标
print(l.index(5))
#删除指定位置的元素并返回
i = l.pop(7)	#下标为7
print(l, i)
#删除找到的指定元素，无返回值
i = l.remove(7)
print(l, i)
#反转列表
l.reverse()
#排序，可用2个函数，方法sort，函数sorted                           
print(sorted(l, reverse = False))	#正序
print(sorted(l, reverse = True))	#逆序
#列表转集合（去重）
l1 = [1, 2, 3, 4, 4, 2, 6, 3, 3, 2]
l2 = set(l1)
l1 = list(l2)
print(l1)

列表的切片操作（字符串也可切片）

1
2
3
4
5
6
7
l = [1, 2, 3, 4, 5, 6, 7, 8 ,9, 0]
#l[起始位置：结束位置（不包含）：步进]
print(l[0:10:3])
#第一个值默认是起始0位置，第二个值默认是结束位置，第三个值默认为1
print(l[::])
#逆向输出列表的所有元素
print(l[::-1])

使用 range 快速生成有一定规律的列表

1
2
3
4
l = list(range(0, 100, 10))
#range可以只接受一个参数作为结束位置
l2 = list(range(10))
print(l)

元组 (tuple,)

元组是不可变序列，一旦初始化就不能修改

1
2
3
4
5
6
#整型数
t1 = 1
print(type(t1), t1)
#元组
t2 = 2,
print(type(t2), t2)

元组的解包：当将一个元组作为等号右边，若等号左边变量的个数和元组内元素个数相同时，就会将元组的每一个元素按照顺序赋值给前面的变量

1
2
3
4
5
6
7
a, b, c, d = (1, 2, 3, 4)
print(a, b, c, d)
#交换两数，等号右边的b a构成一个临时元组(20, 10)，对这个元组进行解包，赋值给a b
a = 10
b = 20
a, b = b, a
print(a, b)

元组不变指的是保存的内容不变，tuple 的每个元素指向永不变

1
2
3
4
t = (1, [2, 3, 4], 5)
#元组保存的是(1的地址， 列表地址，5的地址)
t[0] = 10		#出错，修改的是元组内第一个元素的值，即修改指向的内容，不能成功
t[1][0] = 10	#正确，修改的是元素二的列表保存的内容，没有修改本身

元组的基本使用与列表一样，就是元组的元素不可改，更为安全，若可能，尽量使用元组而不用列表

集合 {set}

集合的元素间没有特定联系，集合内的数据是保持唯一的

1
2
s = {10, 10, 10, 20, 30, 40, 40}
print(type(s), s)

字典 dict {keys:values}

字典特性：

  1. 键是唯一的，若存在2个一样的键，后者会代替前者
  2. 若访问不存在的键就会报错
  3. 字典的值没有限制，但键存在一定的规定，键不可变，故可以使用数字，字符串，元组，但列表不行
1
2
3
4
5
6
7
8
9
10
d = {'a':1, b:2}
print(type(d), d)
#使用键名访问到值
print(d['a'])

d = {1:1, 2.2:2.2, "3":3, (4,):4}
#获取键，值，键值对
print(d.keys())
print(d.values())
print(d.items())

函数

python 中的函数使用 def 定义，后面紧跟着函数名和参数列表，参数没有指定类型并且也不需要指定返回值类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def func():
    print("这是一个函数")
func()

#接收2个数，返回较大值
def maximum(n1, n2):
    return n1 if n1 > n2 else n2	#若 n1 > n2 成立则返回 n1 否则返回 n2
print(maximum(10, 20))

#一个无返回值的函数
def noreturn():
    pass	#这是一个空函数
	#return None
# 没有指定返回值的函数，默认会返回 None
print(noreturn())

函数的默认参数使用和 C++ 相同，参数的设置必须从右向左

1
2
3
def defaultpram(n, m = 10):
    print(n, m)
defaultpram(20)

调用函数时指定某一个参数的值

1
2
3
def test(a, b, c):
    print(a, b, c)
test(c = 1, a = 2, b = 3)	#这个用法非常的多，一定要记住

给函数传入不确定个数的参数，元组（*），若参数添加了 *，表示接收的数据会被组合成一个元组进行保存，传入的数据是不能被更改的

1
2
3
def func1(*arg):
    print(type(arg), arg)
func1(1, 2, 3, 4)

给函数传入不确定个数的参数，字典（**），当参数指定为 ** 时，表示传入的参数会被组织成一个字典，传入的必须是键值对，传入的内容能够被修改

1
2
3
def func2(**kwarg):
    print(type(kwarg), kwarg)
func2(one = 1, two = 2, three = 3)

在使用过程中，一般两种方式会混用

1
2
def test(*arg, **kwagts):
    pass

作用域

Python 中作用域分为全局和局部（函数内），全局的访问不到局部的

1
2
3
4
5
6
g_num = 100
def test():
    g_num = 10
    print(g_num)
test()
print(g_num)

与 C/C++ 不同，在 Python 的函数内对全局变量的修改只能在函数内有效，函数外全局变量的值不会改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def test():
    number = 10		#number是局部的，函数外不可访问
    global l_num	#可以使用global关键字将局部的修饰为全局的
    l_num = 10
test()
print(globals(), l_num)

g_number = 100
def test():
    # 在函数内可以访问，但是不能直接修改全局的数据
    # 使全局变量能够在函数内进行修改
    global g_number
    g_number = 10
    # 用于输出所有的局部变量
    print(locals())
# 全局的访问不到局部的
test()
print(g_number)