Python基础入门教学
基础中的基础
列表、元组(tuple)、字典、字符串
变量和引用
函数
基础中的基础
解释型语言和编译型语言差距;
Python概述
解释器执行原理
which python3可以查看python3的位置(linux下);
交互式环境中使用exit()或者ctrl+D退出;
9 // 2表示取结果的整数,乘方使用**;
乘法可以用在 字符串中 也就是说 "_ " * 5 会输出5个 “_”;
数据类型分为 数字型和非数字型: (1)数字型 : 整形、浮点型、布尔型、复数型。(2)非数字型: 字符串、列表、元组、字典。type(变量名)查看变量类型;
python3中没有long,只有int;
变量的输入: input()函数。注意: input()函数输入的数据类型都是字符串类型;
在python中,如果变量名需要两个或多个单词组成时,可以按照下面的方式: ①每个单词都是小写;②单词和单词之间使用_下划线连接;③使用驼峰规则;
print函数如果不想输出换行,在后面加上一个end=""(例如print(“a”,end=""));单纯的只想输出一个换行可以使用print()或者print("");
\t(制表符(对齐))和\n转义字符;
关于函数的注释,写在函数的下面,加上三个"""。以及文档注释,例如:
1 defsum_2_sum(a, b):2 """计算a和b的和3 :param a:第一个参数4 :param b:第二个参数5 :return:6 """
7 return a + b
因为函数体相对比较独立,函数定义的上方,应该和其他代码(包括注释)保留两个空行;
import导入的文件可以python解释器将模块解释成一个pyc二进制文件(类似Java的.class?);
python中关键字后面不需要加括号(如del 关键字);
方法和函数的异同: ①方法和函数类似,同样是封装了独立的功能;②方法需要通过对象来调用,表示针对这个对象要做的操作③函数需要记住,但是方法是对象的"函数",方法不需要记住(IDE提示或者IPython中TAB补全);
变量赋值的几种特殊的方式:
1 a = b = c = 1 #三个都是1
2 a, b, c = 1, 2, "hello" #a = 1, b = 2, c = "hello"
3
4 a, b = 0, 1
5 a, b = b, a+b #右边表达式的执行顺序是从左往右的。
6 """
7 上面的代码类似:8 n = b9 m = a+b10 a = n11 b = m12 """
13 print(a) #1
14 print(b) #1
逻辑运算符:and、or、not,成员运算符in、not in,身份运算符is、is not;
列表、元组(tuple)、字典、集合、字符串
列表可以嵌套
1 x = [['a', 'b', 'c'], [1, 2, 3]]2 print(x[0]) #['a', 'b', 'c']
3 print(x[0][1]) #'b'
元组不同于列表的是: 元组不能修改,用()表示;(不能增删改)
元组一般保存不同类型的数据;
注意: 只有一个元素的元组: single_tuple = (5,) ,也就是说元组中只包含一个元素时,需要在元素后面添加逗号;不能这样写 single_tuple = (5),这样是一个整形的变量;另外,创建元组也可以不加上括号;
1 tup = "a", "b", "c", "d"
2 print(tup)3 print(type(tup))4
5 tup2 = ("a",) #一个元素的元组 (后面必须加上一个括号)
6 print(tup2)7 print(type(tup2))
输出:
1 ('a', 'b', 'c', 'd')2
3 ('a',)4
元组的用途: ① 作为函数的参数和返回值;②格式化字符串(格式字符串本身就是一个元组);(3)让列表不可以被修改,保护数据安全;
格式化字符串和元组的关系,看下面的三个print输出是一样的:
1 #元组和格式化字符串的关系
2 info_tuple = ("小明", 21, 1.85)3 print("%s 年龄是 %d 身高是 %.2f" % ("小明", 21, 1.85))4 print("%s 年龄是 %d 身高是 %.2f" %info_tuple)5
6 info_str = "%s 年龄是 %d 身高是 %.2f" %info_tuple7 print(info_str)
元组和列表可以相互转换 : ①使用list(元组)将元组转换成列表;②使用tuple将列表转换成元组;
字典: ① 键必须是唯一的 ②值可以取任意类型,但是键只能使用字符串、数字或者元组(键只能是不可变类型)。
**遍历字典的时候for k in dict 中的k是键,而不是值。(普通的for),不过也可以通过items()方法遍历键值对:
1 dict_student = {'name': 'xiaoming', 'age': '18', 'qq': "1234"}2
3 #遍历方式一
4 for k in dict_student: #k 是key
5 print(k, end=" ")6 print(dict_student[k])7
8 print("*" * 20)9 #遍历方式二
10 for k, v indict_student.items():11 print(k, v)
字符串中的转义字符:\n表示换行,而\r表示回车,字符串中的函数isspace()判断的时候\t\n\r都是表示的空白字符;
isdecimla()、isdigit()、isnumeric()都不能判断字符串中的小数,(可以判断字符串中的整数);
集合set的使用: 可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。 集合还有一些方法add()、update()、pop()等;
1 student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}2 print(student) #输出集合,重复的元素被自动去掉
3
4 if 'Rose' instudent:5 print('Rose 在集合中')6 else:7 print('Rose 不在集合中')8
9 #set可以进行集合运算
10 a = set('abracadabra')11 b = set('alacazam')12
13 print(a - b) #a和b的差集
14 print(a | b) #a和b的并集
15 print(a & b) #a和b的交集
16 print(a ^ b) #a和b中不同时存在的元素
输出:
1 {'Jim', 'Mary', 'Jack', 'Rose', 'Tom'}2 Rose 在集合中3 {'b', 'd', 'r'}4 {'b', 'l', 'c', 'd', 'z', 'm', 'a', 'r'}5 {'c', 'a'}6 {'b', 'm', 'l', 'r', 'd', 'z'}
相关公共方法: len、del、max、min(只会比较字典的key);
in、not in的使用(类似数据库…);
pass关键字的使用: 比如if … 下面没有写语句,python会提示报错,但是你可以写一个pass就不会报错了;也就是说如果在开发程序时,不希望立即编写分支内部的代码,可以使用pass作为一个占位符;可以保证程序代码结构正确;
TODO关键字的使用,在编写程序框架的时候,可以用TODO标示某个地方还没有做某事;
迭代器的使用
1 import sys #引入 sys 模块
2
3 lst = [1, 2, 3, 4]4 it = iter(lst) #创建迭代器对象
5
6 #使用for 遍历迭代器
7 for x init:8 print(x, end=" ")9 print()10
11 it = iter(lst) #之前那个已经到了最后了,再次获取
12 #使用next + while遍历
13 whileTrue:14 try:15 print(next(it), end=" ")16 except StopIteration: #防止无限循环
17 sys.exit() #退出程序
18 print()
输出:
1 1 2 3 4
2 1 2 3 4
字符串中切片的使用: ①类似截取,但是可以指定步长;②python中支持倒序索引,最后一个是-1,倒数第二个是-2…;
1 #切片的使用
2 num_str = "12345678"
3
4 print(num_str[2:6]) #[2,5]
5 print(num_str[2:]) #从2位置到结束
6 print(num_str[0:6]) #输出[0,5]的
7 print(num_str[:6]) #一开始到5的
8 print(num_str[:]) #全部输出
9 print(num_str[::2]) #指定步长 第三个参数指定步长
10 print(num_str[1::2]) #从第一个开始 步长为2
11
12 print("*" * 20)13 print(num_str[-1]) #输出最后一个位置的
14 print(num_str[2:-1]) #从第二个开始到倒数第二个
15
16 print("*" * 20)17 #一个面试题 逆序输出
18 print(num_str[-1::-1]) #步长为-1代表向左切片,从最后一个开始切
19 print(num_str[::-1])
输出:
1 3456
2 345678
3 123456
4 123456
5 12345678
6 1357
7 2468
8 ********************
9 8
10 34567
11 ********************
12 87654321
13 87654321
变量和引用
变量和数据都是保存在内存中的;
在python中函数的参数传递以及返回值都是引用传递的;
变量和数据是分开存储的;
变量中记录数据的地址,就叫做引用;
使用id()函数可以查看变量中保存的数据所在的内存地址;
注意: 如果变量已经被定义,当给一个变量复制的时候,本质上是修改了数据的引用。① 变量不再对之前的数据引用;②变量改为对新复制的数据引用;
可变类型和不可变类型
不可变类型: 内存中的数据不允许修改:
① 数字类型: int、bool、 float、complex、long
② 字符串 :str
③ 元组 :tuple
可变类型: 内存中的数据可以被修改
① 列表 list
② 字典 dict
可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5被丢弃,不是改变a的值,相当于新生成了a;
不可变类型: 变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。
函数参数传递时注意:
不可变类型:类似 c++的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响;
局部变量和全局变量
局部变量:函数内部定义的变量,只能在函数内部使用;
全局变量: 函数外部定义的变量,所有函数内部都可以使用这个变量;(不推荐使用)
注意: 在python中,不允许修改全局变量的值,如果修改,会在函数中定义一个局部变量;
1 num = 10
2
3
4 #python中,不允许修改全局变量
5
6 defmethod1():7 num = 99 #这里没有修改全局变量num,而是自己又定义了一个局部变量,执行完这个函数,局部变量就会回收
8 print(num)9
10
11 defmethod2():12 print(num) #虽然在method1中修改了 num 但是却不会修改
13
14
15 method1()16 method2()17
18 #输出
19 #99
20 #10
可以使用global关键字修改全局变量的值。
全局变量的命名规则: 前面加上g_ 或者gl_;
函数
函数如果返回的是一个元组就可以省略括号;
如果返回的是一个元组,可以使用多个变量直接接收函数的返回结果;(注意变量的个数和返回的元组的个数相同)
例如:
1 ef measure():2 """测量湿度和温度"""
3 temp = 39
4 wetness = 50
5
6 #下面返回的是一个元组,为什么写成没有括号的样子,因为如果返回的是一个元组就可以省略括号
7 #return (temp, wetness)
8 returntemp, wetness9
10
11 res =measure()12 print(res)13 print(type(res)) #tuple
14
15
16 #很骚的,直接使用多个变量接收函数返回的元组
17 gl_temp, gl_wetness =measure()18 print(gl_temp)19 print(gl_wetness)
交换两个变量a、b的值的三种解法(第三种python专用)
1 a = 6
2 b = 100
3
4 #解法1
5 c =a6 a =b7 b =c8 print(a)9 print(b)10
11 #解法2
12
13 a = a +b14 b = a -b15 a = a -b16 print(a)17 print(b)18
19 #解法3 python专用
20 #a, b = (b, a)
21 a, b =b, a22 print(a)23 print(b)
如果在函数中使用赋值语句,并不会影响调用函数时传递的实参变量;无论传递的参数可变还是不可变;
只要针对参数使用赋值语句,会在函数内部修改局部变量的引用,不会影响到外部变量的引用;
测试:
1 defdemo(num, num_list):2 print("函数内部的代码")3
4 num = 100
5 num_list = [1, 2, 3]6
7 print(num)8 print(num_list)9 print("函数执行完成")10
11
12 gl_num = 99
13 gl_list = [4, 5, 6]14 demo(gl_num, gl_list)15 print(gl_num) #99
16 print(gl_list) #[4, 5, 6]
输出:
1 函数内部的代码2 100
3 [1, 2, 3]4 函数执行完成5 99
6 [4, 5, 6]
一张图解释:
如果传递的参数是可变类型,在函数内部,使用方法修改了数据的内容,同样会影响到外部的数据。
1 defdemo(num_list):2 print("函数内部的代码")3 num_list.append(666)4 print(num_list)5 print("函数代码执行结束")6
7
8 gl_list = [1, 2, 3]9 demo(gl_list)10 print(gl_list)
输出:
1 函数内部的代码2 [1, 2, 3, 666]3 函数代码执行结束4 [1, 2, 3, 666]
示意图:
上面写了,这里再重复一遍可变类型和不可变类型和参数传递的关系:
不可变类型:类似 c++的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响;
列表变量调用 += 的时候相当于是调用extend,这个是一个特列;
1 defdemo(num, num_list):2 print("函数开始")3
4 #赋值语句 不会改变外部
5 num +=num6
7 #但是列表是一个特例,+=列表相当于 extend 所以会改变外部
8 num_list +=num_list9 #num_list = num_list + num_list # 这样就不会改变实参
10
11 print(num)12 print(num_list)13
14 print("函数结束")15
16 gl_num = 9
17 gl_list = [1, 2, 3]18
19 demo(gl_num, gl_list)20
21 print(gl_num)22 print(gl_list)
输出:
1 函数开始2 18
3 [1, 2, 3, 1, 2, 3]4 函数结束5 9
6 [1, 2, 3, 1, 2, 3]
缺省参数: ①定义函数时,可以给某个参数指定一个默认值,指定了默认值的参数叫做缺省参数;②一般使用最常见的值作为缺省参数;③缺省参数的定义位置:必须保证带有默认值的缺省参数定义在参数列表的末尾;
1 def print_info(name, gender=True):2 gender_text = "男生"
3 if notgender:4 gender_text = "女生"
5 print("%s 是 %s" %(name, gender_text))6
7 print_info("小明") #缺省参数 使用最常见的值,作为缺省参数
8 print_info("小美", False)
还要注意,如果后面有多个参数,且只给具体的某一个指定默认值,就要具体的指定参数的名字:
1 def print_info(name, title="", gender=True):2 gender_text = "男生"
3 if notgender:4 gender_text = "女生"
5 print("%s 是 %s" %(name, gender_text))6
7 print_info("小明")8 print_info("小美", False) #这个是错误的
9 print_info("小美", gender=False) #这里必须指定为gender
输出:
这个原理类似降序排序:
1 gl_list = [6, 3, 9]2 gl_list.sort(reverse=True)3 print(gl_list)
多值参数
1 def demo(num, *args, **kwargs): #多值参数 *接收元组 **接收字典
2 print(num)3 print(args)4 print(kwargs)
输出:
1 1
2 (2, 3, 4, 5)3 {'name': '小明', 'age': 18}
使用多值参数的好处,例如下面的例子计算求和,如果不使用* args 也就是不使用多值的元组的时候,我们传递参数的时候就需要传递一个元组,但是这样的话就直接传递一串数字就好了。
1 def sum_number(*args):2 res =03 for n inargs:4 res +=n5 returnres6
7
8 print(sum_number(1, 2, 3, 4, 5))9 #print(sum_number((1, 2, 3, 4, 5))) # 如果不加上*的话就要加上这个表示元组的括号
多值参数元组和字典的拆包
首先看下面代码的输出,这个代码是出乎意料的:
1 def demo(*args, **kwargs):2 print(args)3 print(kwargs)4
5
6 gl_tuple = (1, 2, 3)7 gl_dict = {"name": "小明", "age": 18}8
9 demo(gl_tuple, gl_dict)
输出:
1 ((1, 2, 3), {'name': '小明', 'age': 18})2 {}
加上拆包:
1 def demo(*args, **kwargs):2 print(args)3 print(kwargs)4
5
6 gl_tuple = (1, 2, 3)7 gl_dict = {"name": "小明", "age": 18}8
9 demo(*gl_tuple, **gl_dict) #注意这里加上了拆包 类似与之前的传递参数
输出:
1 (1, 2, 3)2 {'name': '小明', 'age': 18