python学习第五节：python的基础语法

python学习第五节：python的基础语法

一、python的注释符

注释也就是备注说明的意思，在代码中不会运行。

1.单行注释：使用 "#"符号注释：

2.多行注释：使用一对三个英文单引号注释

3.多行注释：使用一对三个英文双引号注释

二、Python的输入和输出

1.输入

在python中，使用input()方法来获取控制台输入的内容。

示例：

print("请输入您要输入的信息：")
a=input() #这个是在控制台开启输入，a就是输入的内容
print("您输入的信息是：",a)

控制台：

输入：大家好，我是渣渣辉！

2.输出

在Python中，如果想要输出一些特定数据，我们就必须用到print()函数

直接输出：

print("您好，这是一个简单的输出语句！")

输出单个变量：

s="这是一个简单的变量！"
print(s)

输入多个变量:

s="这是一个简单的变量！"
t="这是第二个简单的变量！"
print(s + t)
print(s , t)

三、Python的数据类型

在python中数据类型主要是以下9种分别是1. Int（整型）；2. Float（浮点型）；3. Bool（布尔型）；4. Str（字符串）；5. None（空值）；6. List（列表）；7. Tuple（元组）；8. Dict（字典）；9. Set（集合）等。

当然，如果你想判断该数字的数据类型，你可以尝试用type()函数来判定，如以下代码实例

a1=10 #Int 整型
a2=12.345 #Float 浮点型
a3=True #Bool 布尔型
a4="这是一个字符串" #Str 字符串
a5=None #None 空值
a6=[12,22,33,44,55,66] #List 列表
a7=(11,) #Tuple 元组
a8={"name":"张三","age":18,"sex":True} #Dict 字典
a9=set() #Set 集合
print(type(a1),type(a2),type(a3),type(a4),type(a5),type(a6),type(a7),type(a8),type(a9))

1、Int整数

定义整数变量

v=10
print(v , -v,type(v)) #type(v) 可返回V的类型

运算符

+	加，用于将两个数相加。
-	减，用于将第一个数减去第二个数
*	乘，用于将两个数相乘。
/	除，用于将第一个数除以第二个数。
%	求余，用于获取两个数相除的余数。
//	整除，用于获取两个数相除的整数部分。
**	幂的次方，用于将一个数的值提高到另一个数的幂次方。

示例：

a=10
b=20
print(a,b)
c=a/b
print(a+b,b-a,a*b,c,a%b,a//b,a**2)

将其他类型转换为整数

print(int("123")) #将字符串转换为整数
print(int(3.1415926)) #将浮点类型转换为整数
print(int(True) , int(False)) #将布尔类型转换为整数

2、Float 浮点型

浮点数用于表示带有小数点的数值，支持科学计数法

定义浮点类型变量

f=3.1415926
print(f ,-f ,type(f))

小数四舍五入

print(round(3.1415926,2)) #保留两位小数

浮点运算符

+	加，用于将两个数相加。
-	减，用于将第一个数减去第二个数
*	乘，用于将两个数相乘。
/	除，用于将第一个数除以第二个数。
**	幂运算，用于将一个数的值提高到另一个数的幂次方

示例：

n1=3.1415
n2=3.12
print("浮点加法：",n1 + n2)
print("浮点减法：",n1 - n2)
print("浮点乘法：",n1 * n2)
print("浮点除法：",n1 / n2)
print("浮点求幂：",n1 ** n2)

将其他类型转换为浮点

print(float("3.1415") , float("3e8")) #将字符串转换为浮点
print(float(10)) #将整数转换为浮点
print(float(True) , float(False)) #将布尔类型转换为浮点

3、Bool 布尔型

布尔值只有True和False

定义变量

b1=True
b2=False
print(b1 , type(b1))

将其他类型转换为布尔值

bool可以将任意类型转换为布尔值

print(bool(0) , type(0))
print(bool(3.1415) , type(3.1415))
print(bool("") , type(""))
print(bool("你好") , type("你好"))
print(bool(None) , type(None))

4、Str 字符串

字符串是由字符组成的序列，用于表示文本数据。字符串可以用单引号（' '）、双引号（" "）或三引号（''' ''' 或 """ """）来定义。三引号通常用于定义多行字符串。

定义变量

s="你好啊，这是一个字符串fjashf0.-+*/-=/.,<>》《】【"
print(s , type(s))

字符串字符遍历

s="你好，我是中国人"
for ss in s:
	print(ss)
print("这个字符串的长度是：" , len(s))
for i in range(8):
    print(i , s[i])

字符串常见函数

基本操作方法：
str(): 将其他类型转换为字符串。
len(): 返回字符串的长度。
+: 字符串连接。

字符串内容判断方法：
str.isalnum(): 如果字符串只包含字母和数字，则返回 True。
str.isalpha(): 如果字符串只包含字母，则返回 True。
str.isdigit(): 如果字符串只包含数字，则返回 True。
str.islower(): 如果字符串中的所有字母都是小写，则返回 True。
str.isupper(): 如果字符串中的所有字母都是大写，则返回 True。
str.isspace(): 如果字符串只包含空白字符，则返回 True。
str.isnumeric(): 如果字符串只包含数字字符，则返回 True。
str.startswith("你好")：检查字符串是否以指定的前缀开始，是则返回True，否则输出False.
Str.endswith("你好"):检查字符串是否以指定的后缀结束，是则返回True，否则输出False.

字符串查找和替换方法：
str.find(sub): 返回子字符串 sub 在字符串中的最低索引，如果未找到则返回 -1。
str.rfind(sub): 返回子字符串 sub 在字符串中的最高索引，如果未找到则返回 -1。
str.index(sub): 返回子字符串 sub 在字符串中的最低索引，如果未找到则引发 ValueError。
str.rindex(sub): 返回子字符串 sub 在字符串中的最高索引，如果未找到则引发 ValueError。
str.replace(old, new): 返回字符串的副本，其中所有的子字符串 old 都被替换为 new。

字符串分割和连接方法：
str.split(sep): 使用指定的分隔符 sep 将字符串拆分为列表。
str.rsplit(sep): 从右侧开始使用指定的分隔符 sep 将字符串拆分为列表。
str.splitlines(): 按行分割字符串，返回一个包含各行的列表。
str.join(iterable): 在 iterable 的每个元素之间插入字符串str，并返回连接后的字符串。

字符串格式化方法：
str.format(*args, **kwargs): 使用位置参数和关键字参数格式化字符串。示例：print('{}{}'.format('字符串1','字符串2'))
str.format_map(mapping): 使用字典映射格式化字符串。
示例：
mapping = {'name': 'John', 'age': '25'}
# 使用format_map()方法
print("My name is {name} and I'm {age} years old.".format_map(mapping))
# 输出：My name is John and I'm 25 years old.


字符串大小写转换方法：
str.lower(): 将字符串中的所有字符转换为小写。
str.upper(): 将字符串中的所有字符转换为大写。
str.capitalize(): 将字符串的第一个字符转换为大写，其余字符转换为小写。
str.title(): 将字符串中的每个单词的首字母转换为大写，其余字符转换为小写。
str.swapcase(): 将字符串中的大写字母转换为小写，小写字母转换为大写。

字符串对齐方法：
str.center(width): 返回一个原字符串居中，并使用空格填充至指定宽度的新字符串。
str.ljust(width): 返回一个原字符串左对齐，并使用空格填充至指定宽度的新字符串。
str.rjust(width): 返回一个原字符串右对齐，并使用空格填充至指定宽度的新字符串。
str.zfill(width): 返回一个原字符串右对齐，并在左侧填充 0 至指定宽度的新字符串。

字符串修剪方法：
str.strip([chars]): 去除字符串两端的指定字符（默认为空格）。
str.lstrip([chars]): 去除字符串左端的指定字符（默认为空格）。
str.rstrip([chars]): 去除字符串右端的指定字符（默认为空格）。

将其他类型转换成字符串

print(str(10) , type(10))
print(str(3.1415) , type(3.1415))
print(str(True) , type(True))
print(str(None) , type(None))

5、None 空值

None 表示空值或者不存在的值

s=None
print(s , type(s))

6、List 列表

在Python中，列表（List）是一种有序的集合，可以包含任意类型的对象，包括数字、字符串、甚至其他列表等。列表是可变的，这意味着在创建后可以修改列表的内容。列表使用方括号[]定义，并且列表中的元素通过逗号,分隔。列表中的元素是可重复的。

定义变量

l=[11,22.33,33,44,55,66,77,88,99,"123",True]

列表的常见函数

List.append(object)：在列表的末尾添加一个元素。
List.insert(index,object)：在指定位置插入一个元素
List.extend(iterable)：将可迭代元素（任何可迭代对象（列表、集合、元组等））的每个元素依次放在列表末尾
示例：
fruits = ['apple', 'banana', 'cherry']
cars = ['Ford', 'BMW', 'Volvo']
fruits.extend(cars)

List.remove(element)：删除指定的值，如果值不存在则报错。
List.pop(index)：index省略则代表删除末尾，也可以删除指定索引对应的元素返回被删除的元素。
List.clear()：清空列表。
List.index(value)：通过元素的值获取元素的下标索引。
List.count(value)：获取元素出现的次数。
List.reverse()：翻转列表中的元素，逆序。
List.sort()：排序，默认升序；list.sort(reverse=True)降序；list.sort(reverse=Flse)升序；
in：判断是否存在，存在返回True，不存在返回False;
示例：
for c in "hello world":
	print(c)
	print("h" in "hello") #返回True

遍历列表

方式一：for e in list: ---不需要索引，直接获取元素

方式二：for i in range(len(list)): ---需要索引，通过索引获取列表内容

7、Tuple 元组

元组（Tuple）是Python中的一种内置数据类型，用于存储一系列有序的元素。与列表（List）相似，但元组是不可变的（immutable），即一旦创建，就不能修改其内部的元素。元组使用圆括号()来定义，元素之间用逗号,分隔。如果元组中只有一个元素，需要在该元素后面加上逗号,以区分于该元素本身和元组。

创建元组

t1=() #创建空元组
t2=(10,) 或 t2=("你好啊",) #创建单元素元组
t3=(10,3.1415,"hello world",False,None,[],(22,33,44)) #创建多元素元组

将其他类型转换为元组

t2=tuple([11,22,33]) #tuple 将列表转换成元组；打印：(11, 22, 33)
t3=tuple(range(10)) #将range 序列转换成元组；打印：(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

遍历元组

t2=tuple([11,22,33]) #tuple 将列表转换成元组；打印：(11, 22, 33)
for item in t2:
	print(item)
print("------------------")
for i in range(len(t2)):
	print(t2[i]) 

元组常用函数

t2.conut(object)：返回指定元素出现的次数，找不到返回0

t2.index(object)：返回指定元素对应的索引，不存在则报错

元组链接，使用 + 号拼接多个元组

t1=(11,22,33)
t2=(55,66,77)
t3=t1 + t2
print(t3) #输出结果：(11,22,33,55,66,77)

复制元组/重复元组，使用乘号 * 重复元组中的元素

t1=(1,2,3)
t2=t1 * 3
print(t2) #输出结果：(1,2,3,1,2,3,1,2,3)

8、Dict 字典

字典（Dictionary）是Python中一种用于存储键值对（key-value pair）的数据结构。每个键（key）都与一个值（value）相关联，键必须是唯一的，但值可以是任意数据类型（如整数、字符串、列表、甚至其他字典）。字典的创建使用花括号 {}，每个键值对使用冒号 : 分隔，键和值之间使用逗号 , 分隔。

列表、元组、字典 三则对比

List列表：一个变量可以存储多个数据，获取目标元素需要从列表第一个元素开始逐个获取

Tuple元组：不可变的list，内存管理更高效

Dict字典：一个变量可以存储多个数据，通过键值对的形式

优点：通过键可以快速获取对应的值

缺点：存储值时需要额外存储键

定义字典

d1={} 或 d1=dict() #定义一个空字典
d2={
    "name":"张三",
    "age":18
}
字典中的键都是唯一的，并是不可变的数据类型，类似java的map集合，或者json格式；

字典的常见操作

访问字典中的值：使用键来访问字典中的值

d2={
    "name":"张三",
    "age":18
}
print(d2["name"]) #输出结果：张三
print(d2.get("name")) #输出结果：张三

修改字典中的值：通过键来修改对应的值

d2={
    "name":"张三",
    "age":18
}
print(d2)
d2["name"]="李四"
print("修改之后：",d2)

添加新的键值对：直接复制一个新的键和值即可

d2={
    "name":"张三",
    "age":18
}
print(d2)
d2["sex"]="男"
print("添加之后：",d2)

删除字典中的键值对：使用pop函数删除指定的键值对

d2={
    "name":"张三",
    "age":18
}
print(d2)
d2["sex"]="男"
print("添加之后：",d2)
d3=d2.pop("sex")
print("删除之后：",d3)

检查键是否存在：使用In 关键字检查字典中是否存在指定的键

print("name" in d2) #True

获取所有键或者值：使用keys()方法获取所有键，使用values()方法获取所有值

d2={
    "name":"张三",
    "age":18,
    "sec":"男"
}
print("keys:",d2.keys()) 
print("values",d2.values())
#一般使用这两个方法都是用于遍历字典：
print("遍历所有键")
for k in d2.keys():
    print(k)
print("遍历所有值")
for v in d2.values():
    print(v)

9、Set 集合

在Python中，集合（Set）是一种无序且元素唯一的数据集合。集合通常用于去重或者检查成员是否存在，其元素可以是任何不可变的数据类型，比如整数、浮点数、字符串或元组。集合使用花括号 {} 来创建，元素之间使用逗号 , 分隔。

定义集合

s=set() #定义一个空集合
错误方法：
s={} #不能这样定义集合，因为这样定义出来的是空字典。

s1={1,3.1415,"你好",None,False,(1,2,3)} #定义一个多元素集合

在集合中，每个元素本身就是唯一的键，因此没有键值对的概念。集合中的元素就是值

集合的去重和无序: 集合是无序的，里面的元素是唯一的，集合中的数字会自动从小到大排序。

集合的常用方法

添加元素：使用add()或者update()方法向集合中添加单个元素

s2={1,2,3,4,5,6}
print("原始集合：",s2)
s2.add(7)
print("add元素之后：",s2)
s2.update({3,5,7,9,10})
print("update元素之后：",s2)

移除元素：使用remove()或者pop()方法移除集合中的指定元素，如果元素不存在则会报错keyError

set.pop()：括号中不写参数，表示随机删除其中一个元素

set.remove(value)：根据元素的值进行删除

set.discard()：根据元素的值进行删除，当删除的值不存在时也不会报错

集合运算-并集：使用union()方法或者 | 运算符

并集，就是将两个集合合并在一起，重复的元素自动去重

示例：

s1={1,3,5}
s2={3,6,9}
s3=s1.union(s2)
s4=s1 | s2
print("s3=",s3)
print("s4=",s4)

集合运算-交集：使用intersection()方法或者 & 运算符

交集，就是求两个集合中相同的部分

示例：

s1={1,3,5,7,9}
s2={3,6,9}
s3=s1.intersection(s2)
s4=s1 & s2
print("s3=",s3)
print("s4=",s4)

集合运算-差集：使用difference()方法和 - 运算符

差集，就是减去指定集合相同的部分

示例：

s1={1,3,5,7,9}
s2={3,6,9}
s3=s1.difference(s2)
s4=s1 - s2
print("s3=",s3)
print("s4=",s4)

集合运算-清空集合：使用clear()方法清空集合中的所有元素

示例：

s1={1,3,5,7,9}
s1.clear()
print(s1) #打印结果：set()

10.数据类型总结

在python中，数据类型分为可变（mutable）和不可变（immutable）两种类型：

可变数据类型：

源内存空间中的数据可以修改不需要开辟新内存空间,只要在源内存基础上修改数据。

List列表：列表可以通过添加、删除、更改元素来改变其内容

Dict字典：字典中的键和值可以添加、修改、删除

Set集合：集合支持添加、修改、删除操作

不可变数据类型：

源内存空间中数据不允许修改, 如果想要修改, 只能开辟新内存空间,让变量引用指向新内存空间数据的地址，这就是不可变数据类型。

Int整数：整数是不可变类型，一旦创建就不能更改其值，而针对int变量重新赋值其实不是值改变，而是重新创建了一个新的int对象，并将值赋给了这个新对象。

Float浮点：浮点也是不可变的，重新赋值就是重新创建对象。

Bool布尔：布尔值

Str字符串

Tuple元组

可变性的概念在于是否允许对象在被创建后修改其值或结构。可变对象可以在运行时改变其值或内容，而不可变对象在创建后保持不变。

四、判断语句

在python中，判断语句有if、if...else、if...elif...else。关键词有or 和 and

1.if的用法

a=10
b=20
if a<b:
	print("a的值比b的值小！")

2.if...else的用法

if a<b:
	print("a的值比b的值小！")
else:
	print("a的值不比b的值小！")

3.if...elif...else的用法

if a<b:
	print("a的值比b的值小！")
elif a==b:
	print("a的值与b的值相等！")
else:
	print("a的值比b的值大！")

4.and的用法

原理：我们在判断时有可能存在多个条件需要同时满足，and就表示并且，如果加上and 表示两个条件都满足，这个判断结果才是真。

示例：

if a==10 and b==20:  #这里解释为 如果a等于10 并且 b等于20，那么就表示条件为真
	print("a的值是10并且b的值是20！") 
else: #这里解释为 a的值不等于10 或者 b的值不等于20
	print("a的值不等于10 或者 b的值不等于20")

5.or的用法

原理：在判断时有可能存在多个条件只需要满足其中一个条件，or就表示或者，如果加上or 表示多个条件只需要满足一个，这个判断结果就是真。

示例：如果这个女孩的年龄是13岁或者14岁或者15岁她在上初中，年龄是16岁或者17岁或者18岁她在上高中，否则她还在上小学或者已经毕业。

if age==13 or age==14 or age==15:
	print("她在上初中") 
elif age==16 or age==17 or age==18:
	print("她在上高中") 
else:
	print("她还在上小学或者已经毕业")

6.操作用算符

<：小于；用于判断变量是否小于常量
>：大于；用于判断变量是否大于常量
>=：大于或者等于；用于判断变量是否大于或者等于常量
<=：小于或者等于；用于判断变量是否小于或者等于常量
==：等于；用于判断两个常量是否相等
!=：不等于；用于判断两个常量是否不相等

示例：

if age>3 and age<6:
	print("他在上幼儿园")
elif age>=6 and age<=12:
	print("他在上小学") 
elif age==13 or age==14 or age==15:
	print("他在上初中")
elif age>30 and age!=65:
	print("他还未退休") 
else:
	print("不知道怎么编了")

五、循环语句

在python中，循环语句有for和while

1.for循环语句

在python中，for循环可以遍历任何可迭代对象，如列表或者字符串等

示例：

for i in range(1,8):
    print(i)

a="你是一个大聪明！"
for s in range(len(a)):
    print("下标数是：",s)
    print("对应的字符是：",a[s])

li = ['a',5,65,654,6545,4,464,4,':',4,48789,]
for i in range(len(li)):
    print(i,':',li[i])

2.while循环语句

Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：

while 判断条件(condition)：

执行语句(statements)......

执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假 false 时，循环结束。

原理：

https://www.runoob.com/wp-content/uploads/2014/05/006faQNTgw1f5wnm06h3ug30ci08cake.gif

3.break语句和continue语句

在循环中，我们有时候也需要阻断循环或者跳出循环，这个时候就需要用到break和continue。

break：表示阻断、停止循环，

continue：表示跳出本次循环，继续下一次循环

pass：这是一个空语句，不会影响代码正常运行，只用于保持程序结构的完整性

六、日期与时间

Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

1.时间戳

import time #引入time模块
t=time.time() #获取时间戳
print(t)

2.时间元组

在python中，通过localtime()方法将时间戳转换成时间元组

序号	属性	    值
0	tm_year	2008
1	tm_mon	1 到 12
2	tm_mday	1 到 31
3	tm_hour	0 到 23
4	tm_min	0 到 59
5	tm_sec	0 到 61 (60或61 是闰秒)
6	tm_wday	0到6 (0是周一)
7	tm_yday	1 到 366(儒略历)
8	tm_isdst	-1, 0, 1, -1是决定是否为夏令时的旗帜

获取当前时间：

import time #引入time模块
localtime = time.localtime(time.time())
print ("当前时间为 :", localtime) 

3.格式化时间

最简单的格式化时间方式就是使用asctime()方法

import time #引入time模块
localtime = time.asctime( time.localtime(time.time()) )
print ("当前时间为 :", localtime)

使用time模块的strftime方法来将时间格式化成指定格式

import time #引入time模块
# 格式化成2016-03-20 11:45:39形式
tt=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print ("1=",tt) #打印结果：2024-09-04 16:10:32
# 格式化成Sat Mar 28 22:24:24 2016形式
tt=time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
print ("2=",tt) #打印结果：Wed Sep 04 16:10:32 2024
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
tt=time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y"))
print ("3=",tt) #打印结果：1459175064.0

python中时间日期格式化符号：

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00-59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

4.获取某月日历

import calendar
cal = calendar.month(2024, 9)
print("以下输出2024年9月份的日历:")
print(cal)

5.Time模块

Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：

1	time.altzone
返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
2	time.asctime([tupletime])
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
3	time.clock( )
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
4	time.ctime([secs])
作用相当于asctime(localtime(secs))，未给参数相当于asctime()
5	time.gmtime([secs])
接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
6	time.localtime([secs])
接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
7	time.mktime(tupletime)
接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。
8	time.sleep(secs)
推迟调用线程的运行，secs指秒数。
9	time.strftime(fmt[,tupletime])
接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
10	time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
根据fmt的格式把一个时间字符串解析为时间元组。
11	time.time( )
返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
12	time.tzset()
根据环境变量TZ重新初始化时间相关设置。

6.日历calendar模块

此模块的函数都是日历相关的，例如打印某月的字符月历。

星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：

1	calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
2	calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一。
3	calendar.isleap(year)
是闰年返回 True，否则为 False。
>>> import calendar>>> print(calendar.isleap(2000))True>>> print(calendar.isleap(1900))False
4	calendar.leapdays(y1,y2)
返回在Y1，Y2两年之间的闰年总数。
5	calendar.month(year,month,w=2,l=1)
返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
6	calendar.monthcalendar(year,month)
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
7	calendar.monthrange(year,month)
返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
8	calendar.prcal(year,w=2,l=1,c=6)
相当于 print calendar.calendar(year,w=2,l=1,c=6)。
9	calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.month(year,month,w=2,l=1) 。
10	calendar.setfirstweekday(weekday)
设置每周的起始日期码。0（星期一）到6（星期日）。
11	calendar.timegm(tupletime)
和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。
12	calendar.weekday(year,month,day)
返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。

七、函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

1.定义函数

定义函数以 def 关键词开头，后面接函数名称和小括号，如果有参数将参数放入小括号中

def myfunction(param):
	print("自定义函数myfunction中传递的参数是：",param) 
	return param

2.函数调用

myfunction("我调用了我创建的自定义函数")

3.默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。

def myf(name,age,sex="男"):
	print("自定义函数myfunction中传递的参数name是：",name) 
	print("自定义函数myfunction中传递的参数age是：",age) 
	print("自定义函数myfunction中传递的参数sex是：",sex) 

myf('张三',20,'女') #打印结果：张三 20 女
myf('李四',18) #打印结果：李四 18 男

4.不定长参数

也就是创建函数是不确定参数个数，我们在参数名前加 * 号表示这个参数有N个，不确定有多少个。

def myf(arg1,*var):
	print(arg1)
	for v in var:
		print(v)
	return
调用方法：
myf(12) #打印结果：12
myf(11,15,33,66,88,99) #打印结果：11 15 33 66 88 99

5.全局变量和局部变量

在函数外声明的变量是全局变量，在函数外声明的变量是局部变量

a=0 #这是全局变量
def sum(arg1,arg2):
	a=arg1+arg2
	print(a)
	return a
调用函数
sum(10,20) #打印结果：30
print(a) #打印结果：0

八、模块

模块就是单独的python文件，也是java中的类；因为我们写代码的时候不可能将所有代码都写入一个python文件中，需要分文件，而这个文件就是一个模块。

1.创建模块

创建模块就是创建python文件

比如 user.py模块

def p_func(s):
	print(s)
	return

2.模块引入 import 语句

当我们在一个模块中需要使用另外一个模块的函数时，需要先引入这个模块，然后才可以调用此模块中的函数

#引入模块
import user 
#调用模块中的方法
user.p_func("哈哈哈") #打印结果：哈哈哈

3.from...import 语句

当我们在模块中要使用另外一个模块中的方法，但是又不想把整个模块都引入过来，只想要引入我想要的方法

#引入方法
from user import p_func
#调用函数
p_func("哈哈哈") #打印结果：哈哈哈

4.from...import* 语句

此语句与import语句类似，都是将指定模块所有内容都引入

九、文件I/O

Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。

1.open函数

用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。

语法：file object = open(file_name [, access_mode][, buffering])

file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。

access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。

buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

不同模式打开文件的完全列表：

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

2.File对象的属性

一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。

以下是和file对象相关的所有属性的列表：

属性	        描述
file.closed	返回true如果文件已被关闭，否则返回false。
file.mode	返回被打开文件的访问模式。
file.name	返回文件的名称。
file.softspace	如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

示例：

fo=open("xxx.txt", "w") 
print("文件名称：", fo.name)  #打印结果：xxx.txt
print("是否已关闭：", fo.closed)  #打印结果：False
print("访问模式：", fo.mode)  #打印结果：w
print("末尾是否强制加空格：", fo.softspace)  #打印结果：0

close()方法

File 对象的 close()方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。当一个文件对象的引用被重新指定给另一个文件时，Python会关闭之前的文件。用 close()方法关闭文件是一个很好的习惯。

语法：

fo.close() #关闭打开的文件

write()方法

write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。write()方法不会在字符串的结尾添加换行符('\n')：

语法：

fo.write("这是在文件中加入的一句话")

read()方法

在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾.

示例：

#打开文件
fo=open("xxx.txt", "w")
#写入内容
fo.write("这是在文件中加入的一句话")
#读取内容
s=fo.read(3)
Print(s) #打印结果：这是在
#关闭文件
fo.close() 

3.文件定位

tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。

seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

示例：

# 打开一个文件
fo = open("xxx.txt", "r+")
#写入内容
fo.write("这是在文件中加入的一句话")
#读取内容
s= fo.read(3) 
print ("读取的字符串是 : ", s) #打印结果：这是在
# 查找当前位置
position = fo.tell()
print ("当前文件位置 : ", position) #打印结果：6
#再次读取内容
s= fo.read(3)
print ("二次读取的字符串是 : ", s) #打印结果：文件中
# 查找当前位置
position = fo.tell()
print ("当前文件位置1 : ", position) #打印结果：12
# 把指针再次重新定位到文件开头
position = fo.seek(0, 0)
s= fo.read(3)
print ("重新读取字符串 : ", s) #打印结果：这是在
# 关闭打开的文件
fo.close()

4.重命名和删除文件

Python的os模块提供了帮你执行文件处理操作的方法，比如重命名和删除文件。要使用这个模块，你必须先导入它，然后才可以调用相关的各种功能。

rename()方法

rename()方法有两个参数，当前的文件地址和名称和新的文件地址和名称。此方法可以将文件移动到相同磁盘的任意位置。

import os
os.rename("E://234.txt","E://12/345.txt")

remove()方法

你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。

import os
os.remove("E://12/345.txt");

5.目录管理

创建目录：mkdir()方法

可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。

语法：

os.mkdir("E://222")
注意：只可以一级一级创建目录，不可以同时创建多级目录

切换目录：chdir()方法

切换目录也就是修改进入的目录，比如开始你进入了E盘，现在需要操作F盘的文件，就需要切换到F盘目录去。

os.chdir("F://222")

显示当前目录：getcwd()

通过getcwd()方法可以获取当前所处目录

p=os.getcwd() #如果上面没有改变目录，此方法获取到的就是本python文件所在的目录。

删除目录：rmdir()方法

使用rmdir()方法可以删除目录（也就是文件夹），但是前提是这个目录下没有任何文件和目录。

os.rmdir("E://222/333")

十、Flie方法

1.open()方法

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)：

open(file, mode='r')

完整的语法格式为：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明:
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
mode 参数有：
模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
默认为文本模式，如果要以二进制模式打开，加上 b 。

2.file对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

file.close()

关闭文件。关闭后文件不能再进行读写操作。

file.flush()

刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

file.isatty()

如果文件连接到一个终端设备返回 True，否则返回 False。

file.fileno()

返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上

file.next()

返回文件下一行

file.read([size])

从文件中去读指定的字节数，如果为给定或者为负数则读取所有。

file.readline([size])

从文件中读取整行，包括"\n"字符。如果指定了一个非负的参数，则返回指定大小的字节数，包括"\n"字符。

file.readlines([size])

从文件中读取所有行，如果size>0，则读取指定的字节数，这是为了减轻读取压力。

file.seek(offset[, whence])

seek() 方法用于移动文件读取指针到指定位置。

Offset：开始的偏移量，也就是代表需要移动偏移的字节数

whence：可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。

返回值：如果操作成功，则返回新的文件位置，如果操作失败，则函数返回 -1。

file.tell()

返回文件当前位置。当前读取到文件内部哪一个下标位置

file.truncate([size])

truncate() 方法用于截断文件，如果指定了可选参数 size，则表示截断文件为 size 个字符。 如果没有指定 size，则从当前位置起截断；截断之后 size 后面的所有字符被删除。

返回值：该方法没有返回值。

示例：

以下实例演示了 truncate() 方法的使用：
文件 runoob.txt 的内容如下：
1:www.runoob.com
2:www.runoob.com
3:www.runoob.com
4:www.runoob.com
5:www.runoob.com
循环读取文件的内容：
# 打开文件
fo = open("runoob.txt", "r+")
print "文件名为: ", fo.name
line = fo.readline()
print "读取第一行: %s" % (line)
# 截断剩下的字符串
fo.truncate()
# 尝试再次读取数据
line = fo.readline()
print "读取数据: %s" % (line)
# 关闭文件
fo.close()
输出结果为：
文件名为:  runoob.txt
读取第一行: 1:www.runoob.com
读取数据:

以下实例截取 runoob.txt 文件的10个字节：
# 打开文件
fo = open("runoob.txt", "r+")
print "文件名为: ", fo.name
# 截取10个字节
fo.truncate(10)
str = fo.read()
print "读取数据: %s" % (str)
# 关闭文件
fo.close()
输出结果为：
文件名为:  runoob.txt
读取数据: 1:www.runo

file.write(str)

write() 方法用于向文件中写入指定字符串。

在文件关闭前或缓冲区刷新前，字符串内容存储在缓冲区中，这时你在文件中是看不到写入的内容的。

如果文件打开模式带 b，那写入文件内容时，str (参数)要用 encode 方法转为 bytes 形式，否则报错：TypeError: a bytes-like object is required, not 'str'。

file writelines() 方法

writelines() 方法用于向文件中写入一序列的字符串。这一序列字符串可以是由迭代对象产生的，如一个字符串列表。换行需要制定换行符 \n。

示例：

seq = ["啊啊啊啊 1\n", "哈哈哈哈 2"]
fo.writelines( seq )

十一、异常处理

1.异常处理

捕捉异常可以使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。

以下为简单的try...except...else的语法：

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。

如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印默认的出错信息）。

如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

示例：

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()

2.使用except而不带任何异常类型

你可以不带任何异常类型使用except，如下实例：

try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码

以上方式try-except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。

3.使用except而带多种异常类型

你也可以使用相同的except语句来处理多个异常信息，如下所示：

try:
    正常的操作
   ......................
except(Exception1[, Exception2[,...ExceptionN]]):
   发生以上多个异常中的一个，执行这块代码
   ......................
else:
    如果没有异常执行这块代码

4.try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

示例：

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print "Error: 没有找到文件或读取文件失败"

或者
try:
    fh = open("testfile", "w")
    try:
        fh.write("这是一个测试文件，用于测试异常!!")
    finally:
        print "关闭文件"
        fh.close()
except IOError:
    print "Error: 没有找到文件或读取文件失败"

5.异常的参数

一个异常可以带上参数，可作为输出的异常信息参数。

你可以通过except语句来捕获异常的参数，如下所示：

try:
    正常的操作
   ......................
except ExceptionType, Argument:
    你可以在这输出 Argument 的值...

变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。元组通常包含错误字符串，错误数字，错误位置。

示例：

# 定义函数
def temp_convert(var):
    try:
        return int(var)
    except ValueError, Argument:
        print "参数没有包含数字\n", Argument

# 调用函数
temp_convert("xyz")
执行结果如下：
参数没有包含数字
invalid literal for int() with base 10: 'xyz'

6.触发异常

我们可以使用raise语句自己触发异常

示例：

def functionName( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 触发异常后，后面的代码就不会再执行

注意：为了能够捕获异常，"except"语句必须有用相同的异常来抛出类对象或者字符串。

例如我们捕获以上异常，"except"语句如下所示：

try:
    正常逻辑
except Exception,err:
    触发自定义异常    
else:
    其余代码

示例：

# 定义函数
def mye( level ):
    if level < 1:
        raise Exception,"Invalid level!"
        # 触发异常后，后面的代码就不会再执行
try:
    mye(0)            # 触发异常
except Exception,err:
    print 1,err
else:
    print 2
输出结果为：
1 Invalid level!

7.用户自定义异常

通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。

以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。

在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。

class Networkerror(RuntimeError):
    def __init__(self, arg):
        self.args = arg

try:
    raise Networkerror("Bad hostname")
except Networkerror,e:
    print e.args