Python基础入门教学

基础中的基础

  • 解释型语言和编译型语言差距；

 

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 def sum_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 = b
 9 m = a+b
10 a = n
11 b = m
12 """
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 <class 'tuple'>
3 ('a',)
4 <class 'tuple'>
  • 元组的用途: ① 作为函数的参数和返回值；②格式化字符串(格式字符串本身就是一个元组)；(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_tuple
7 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 in dict_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' in student:
 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 in it:
 8     print(x, end=" ")
 9 print()
10 
11 it = iter(lst)  # 之前那个已经到了最后了，再次获取
12 # 使用next + while遍历
13 while True:
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 def method1():
 7     num = 99  # 这里没有修改全局变量num，而是自己又定义了一个局部变量，执行完这个函数，局部变量就会回收
 8     print(num)
 9 
10 
11 def method2():
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     return temp, wetness
 9 
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 = a
 6 a = b
 7 b = c
 8 print(a)
 9 print(b)
10 
11 # 解法2
12 
13 a = a + b
14 b = a - b
15 a = a - b
16 print(a)
17 print(b)
18 
19 # 解法3 python专用
20 # a, b = (b, a)
21 a, b = b, a
22 print(a)
23 print(b)
  • 如果在函数中使用赋值语句，并不会影响调用函数时传递的实参变量；无论传递的参数可变还是不可变；
  • 只要针对参数使用赋值语句，会在函数内部修改局部变量的引用，不会影响到外部变量的引用；

测试:

 1 def demo(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 def demo(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 def demo(num, num_list):
 2     print("函数开始")
 3 
 4     # 赋值语句 不会改变外部
 5     num += num
 6 
 7     # 但是列表是一个特例，+=列表相当于 extend 所以会改变外部
 8     num_list += num_list
 9     # 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 not gender:
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 not gender:
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 = 0
3     for n in args:
4         res += n
5     return res
6 
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

 

版权声明：本文为pypypy原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/pypypy/p/11794228.html