wangzhebin's blog
0%

python基础

发表于 更新于 分类于

1. 注释

单行注释：使用#符号表示单行注释，注释内容写在#后面，如下所示：

1
# 这是一条单行注释

多行注释：使用’’’或”””表示多行注释，注释内容写在这两个符号之间，如下所示：

1
2
3
4
5
6
7
'''

这是一条多行注释

可以换行写注释内容

'''

2. 变量

python 中变量很简单，不需要指定数据类型，直接使用等号定义就好。python变量里面存的是内存地址，也就是这个值存在内存里面的哪个地方，如果再把这个变量赋值给另一个变量，新的变量通过之前那个变量知道那个变量值的内存地址存起来，而不是指向之前的那个变量。

定义变量：使用赋值符号=定义变量，变量名由字母、数字、下划线组成，不能以数字开头，如下所示：

1
2
3
x = 10
name = 'Tom'
is_student = True

变量类型：Python中的变量是动态类型的，既不需要事先声明变量的类型，而是在运行时根据值的类型来确定变量的类型，如下所示：

1
2
3
x = 10 # 整数
y = 3.14 # 浮点数
z = 'hello' # 字符串

注意，以下关键字不能声明为变量名：

1
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif'',for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'try', 'while', 'with', 'yield']

3. 数据类型

3.1. 数字

Python中的数字包括整数、浮点数和复数，如下所示：

1
2
3
x = 10 # 整数
y = 3.14 # 浮点数
z = 2 + 3j # 复数

  1. python 中数字类型的变量可以表示任意大的数值

  2. 十六进制一 0x 开头，八进制以 0o 开头，二进制以 0b 开头

  3. python中可以表示复数用j来表示虚部，complex(a，b) 函数可以形成复数

    1
    2
    3
    a=3+4j
    b=complex(5,6)
    c=a+b

  4. real() 查看实部，imag() 查看虚部，conjugate()返回共轭复数

    1
    2
    3
    4
    print(c)
    print(c.real)
    print(c.imag)
    print(c.conjugate())

    运行结果

    1
    2
    3
    4
    (8+10j)
    8.0
    10.0
    (8-10j)

3.2. 字符串

Python中的字符串可以使用单引号、双引号、三单引号和三双引号来表示。三引号也可以多行注释代码，单行注释，使用#。如下所示：

1
2
3
4
5
6
7
8
9
s1 = 'hello' # 单引号字符串
s2 = "world" # 双引号字符串
s3 = '''hello,\nworld''' # 三单引号字符串，可以包含换行符
s4 = """hello,
world""" # 三双引号字符串，可以包含换行符
'''
三引号框起来的
也可以当做多行注释
'''

3.3. 列表

Python中的列表是由一组有序的元素组成，可以包含任意类型的数据，用中括号[]表示，如下所示：

1
list1 = [1, 2, 3, 'hello', 'world'] # 列表中可以包含不同类型的元素

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

1
2
3
4
5
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
 
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

1
2
3
4
list = []               ## 空列表
list.append('Google')   ## 使用 append() 添加元素
list.append('Runoob')
print list

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。如下所示：

img

列表推导式

列表推导式(list comprehension)，可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。语法如下所示：

1
[ 表达式 for 迭代变量 in 可迭代对象 if 条件表达式 ]

不使用列表推导式的语法：

1
2
3
for 迭代变量 in 可迭代对象 :
	if 条件表达式 :
		表达式

举几个栗子：

1
2
3
# 列表推导式
list_b = [b for b in range(5)]
print(list_b)

来看复杂点的列表推导式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# in后面跟其他可迭代对象,如字符串
list_c = [7 * c for c in "python"]
print(list_c)
# ['ppppppp', 'yyyyyyy', 'ttttttt', 'hhhhhhh', 'ooooooo', 'nnnnnnn']
 
# 带if条件语句的列表推导式
list_d = [d for d in range(6) if d % 2 != 0]
print(list_d)
# [1, 3, 5]

# 多个for循环
list_e = [(e, f * f) for e in range(3) for f in range(5, 15, 5)]
print(list_e)
# [(0, 25), (0, 100), (1, 25), (1, 100), (2, 25), (2, 100)]
 
# 嵌套列表推导式,多个并列条件
list_g = [[x for x in range(g - 3, g)] for g in range(22) if g % 3 == 0 and g != 0]
print(list_g)
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14], [15, 16, 17], [18, 19, 20]]
  1. 列表推导式会遍历后面的可迭代对象,然后按照for前的表达式进行运算,生成最终的列表.
  2. 如果有if条件语句,for遍历后紧跟着进行条件判断.
  3. 如果有多个for循环,则最终的数据数量为多个for循环的笛卡尔积.
  4. 可以进行嵌套的列表推导,与嵌套for循环的原理相同.
常用List列表函数&方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Python 包含以下函数:

len(list)：列表元素个数
max(list)：返回列表元素最大值
min(list)：返回列表元素最小值
list(seq)：将元组转换为列表

Python 包含以下方法:

list.append(obj)：在列表末尾添加新的对象
list.count(obj)：统计某个元素在列表中出现的次数
list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)：将对象插入列表
list.pop([index=-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)：移除列表中某个值的第一个匹配项
list.reverse()：反向列表中元素
list.sort(cmp=None, key=None, reverse=False)：对原列表进行排序

3.4. 元组

Python中的元组也是由一组有序的元素组成，但是元素不能修改，用小括号()表示，如下所示：

1
tuple1 = (1, 2, 3, 'hello', 'world') # 元组中可以包含不同类型的元素

3.5. 字典

Python中的字典是由一组键值对组成，用大括号{}表示，如下所示：

1
dict1 = {'name':'Tom', 'age': 18, 'gender': 'male'} # 字典中的键值对用冒号:分隔
字典推导式

如果列表推导的概念已经为你所熟知，接受字典推导并不难.直接看代码吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 因为key是唯一的,所以最后value都是1
dict_a = {key: value for key in 'python' for value in range(2)}
print(dict_a)
# {'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1}
 
# 可以根据键来构造值
dict_b = {key: key * key for key in range(6)}
print(dict_b)
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
 
# 遍历一个有键值关系的可迭代对象
list_phone = [('HUAWEI', '华为'), ('MI', '小米'), ('OPPO', 'OPPO'), ('VIVO', 'VIVO')]
dict_c = {key: value for key, value in list_phone}
print(dict_c)
# {'HUAWEI': '华为', 'MI': '小米', 'OPPO': 'OPPO', 'VIVO': 'VIVO'}

3.6. 集合

Python中的集合是由一组无序的、唯一的元素组成，用大括号{}或set()函数表示，如下所示：

1
2
3
set1 = {1, 2, 3, 4, 5} # 使用大括号{}表示集合

set2 = set([2, 4, 6, 8]) # 使用set()函数创建集合
集合推导式

同样的，直接看代码，这样可以直观的看到集合推导式

1
2
3
# 遍历一个可迭代对象生成集合
set_a = {value for value in '有人云淡风轻,有人负重前行'}
print(set_a)

运行结果:

1
{'负', '有', '人', '轻', '前', '云', '重', ',', '淡', '风', '行'}

集合是无序且不重复的，所以会自动去掉重复的元素，并且每次运行显示的顺序不一样。

4. 条件语句

if语句：用于判断一个条件是否成立，如果成立则执行if块中的语句，否则跳过if块，如下所示：

1
2
if x > 0:
print('x is positive')

if/else语句：用于判断一个条件是否成立，如果成立则执行if块中的语句，否则执行else块中的语句，如下所示：

1
2
3
4
if x > 0:
print('x is positive')
else:
print('x is non-positive')

if/elif/else语句：用于判断多个条件是否成立，如果第一个条件成立则执行if块中的语句，否则判断第二个条件，如果第二个条件成立则执行elif块中的语句，否则执行else块中的语句，如下所示：

1
2
3
4
5
6
if x > 0:
print('x is positive')
elif x == 0:
print('x is zero')
else:
print('x is negative')

5. 循环语句

for循环：用于遍历一个序列（如列表、元组、字符串等），如下所示：

1
2
for item in sequence:
	print(item)

while循环：用于重复执行一段代码，直到条件不成立为止，如下所示：

1
2
while condition:
	statement(s)

6. 函数

定义函数：使用def关键字定义函数，函数名由字母、数字、下划线组成，参数可以有默认值、可变参数、关键字参数等，如下所示：

1
2
3
4
5
6
7
8
def add(x, y):
	return x + y


def foo(x, y=10, \*args, \kwargs):
	print(x, y)
	print(args)
	print(kwargs)

调用函数：使用函数名和参数列表来调用函数，如下所示：

1
2
result = add(1, 2)
foo(1, 2, 3, 4, a=5, b=6)

6.1. range()函数

python 的 range() 函数可用来创建一个整数列表，一般用在 for 循环中.

  • range()语法：range(start, stop[, step])
  • start：计数从start开始，默认是从0开始(闭区间)，如：range(5)等价于range(0,5)。
  • stop：计数到stop结束，但不包括stop(开区间)，如：range(0,5)是[0, 1, 2, 3, 4],不包含5。
  • step：步长，相邻两个值的差值,默认为1，如：range(0,5)相当于range(0, 5, 1)。

7. 模块和包

python 中有大量第三方库可用 “pip3 install 。。。”进行有需要的安装

在使用库函数时，需要导入，有两种方法：

  • import 模块名【as 别名】：使用这种方式导入后，需要在使用的对象前加上前缀 “模块名 . 对项名”的方式进行访问，也可以用“别名 . 对象名”的方式使用其中的对象
  • from 模块名 import 对象名【as 别名】：使用这种方式仅导入使用的对象，并且可以为这个对象起一个别名，这种方法可以减少查询次数，减少程序员的代码量，不需要使用模块名作为前缀

比较极端的情况是一次导入模块中全部的对象：

1
from math import *

不推荐使用这中方法，一旦多个模块中有同名的对象，会导致混乱

8. 创建类

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

1
2
3
class ClassName:
   '''类的帮助信息'''   #类文档字符串
   class_suite  #类体

类的帮助信息可以通过ClassName.__doc__查看。

class_suite 由类成员，方法，数据属性组成。

以下是一个简单的 Python 类的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Employee:
   '所有员工的基类'
   empCount = 0
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
 
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary
  • empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
  • 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
  • self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例它的名称是 self。

8.1. 创建实例对象

实例化类其他编程语言中一般用关键字 new，但是在 Python 中并没有这个关键字，类的实例化类似函数调用方式。

以下使用类的名称 Employee 来实例化，并通过 init 方法接收参数。

1
2
3
4
# 创建 Employee 类的第一个对象
emp1 = Employee("Zara", 2000)
# 创建 Employee 类的第二个对象
emp2 = Employee("Manni", 5000)

8.2.访问属性

可以使用点号 . 来访问对象的属性。使用如下类的名称访问类变量:

1
2
3
4
5
6
7
8
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

# 结果
Name : Zara ,Salary: 2000
Name : Manni ,Salary: 5000
Total Employee 2

可以添加，删除，修改类的属性，如下所示：

1
2
3
emp1.age = 7  # 添加一个 'age' 属性
emp1.age = 8  # 修改 'age' 属性
del emp1.age  # 删除 'age' 属性

也可以使用以下函数的方式来访问属性：

  • getattr(obj, name, [default]) : 访问对象的属性。
  • hasattr(obj,name) : 检查是否存在一个属性。
  • setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
  • delattr(obj, name) : 删除属性。
1
2
3
4
hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(emp1, 'age')    # 删除属性 'age'

9. 格式化输出

　　什么是格式化输出呢，就是说把你的输出都格式化成一个样子的，比如说登录的欢迎信息，都是welcome to login，Marry。每个用户登录都是这样欢迎，但是每个用户的用户名都是一样的，不能一个用户写一行代码，所以这就用到了格式化输出。

格式化输出，有三种方式，

  • 第一种是用“+”连接，直接把输出的字符串和变量连接起来就可以了；

  • 第二种是用占位符，占位符有常用的三种：%s，%d和%f , %s是后面的值是一个字符串，%d后面的值必须是一个整数，%f后面是小数；

  • 第三种是使用{}和format方法。

官方推荐使用format方法，不推荐使用第一种，第一种用加号的，会在内存里面开辟多个内存空间，而后面两种是只开辟一块内存空间。如下所示：

1
2
3
4
5
6
name=input('请输入你的名字:')
print('你的名字是' + name) #使用加号连接
print('你的名字是%s' % name) #使用占位符
print('你的名字是{your_name}'.format(your_name=name)) #使用format格式化输#出，{}里面的名字可以随便写但是要和后面的format中的名字保持一致，然后再把你前面定义的变量写到等号后面就可以了。
age=18
print('我的名字是%s，年龄是%d岁.' %(name, age)) #这种是里面有多个格式化内容的，前面那个是字符串，后面这个是整数，多个变量的后面跟值得时候必须要加上括号