条件语句

基本形式

1
2
3
4
if 判断条件：
    执行语句
else：
    执行语句

if语句可以用>,<,==，>=,<=来表示其关系

由于python没有switch语句，所以在遇到判断条件为多个值时，用下列形式：

1
2
3
4
5
6
if 判断条件1:
	执行语句1
elif 判断条件2:
	执行语句2
else
	执行语句3

在python中，如果满足条件却不做任何操作，使用pass直接跳过

循环语句

循环语句主要分为for循环和while循环

这两者的区别时，当不知道循环次数时，使用后者，反之。

循环控制语句

1
2
3
break语句  用于终止循环，跳出整个循环
continue语句 用于终止当前循环，执行下一次循环
pass语句 保证结构的完整性

while循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1
 
print("Good bye!")

结果为：
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

continue和break的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print(i)         # 输出双数2、4、6、8、10
 
i = 1
while 1:            # 循环条件为1必定成立
    print(i)         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

死循环

1
while True:

循环使用else语句

1
2
3
4
5
6
count = 0
while count < 5:
   print(count, " is  less than 5")
   count = count + 1
else:
   print(count, " is not less than 5")

for循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
for letter in 'Python':     # 第一个实例
   print('当前字母 :', letter)
 
fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
   print('当前水果 :', fruit)
 
print("Good bye!")

结果为：
当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : h
当前字母 : o
当前字母 : n
当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!

通过序列索引迭代

1
2
3
4
5
6
7
8
9
10
11
fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print('当前水果 :', fruits[index])
 
print("Good bye!")

结果为：
当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!

循环使用else语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print('%d 等于 %d * %d' % (num,i,j))
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print(num, '是一个质数')

结果为：
10 等于 2 * 5
11 是一个质数
12 等于 2 * 6
13 是一个质数
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一个质数
18 等于 2 * 9
19 是一个质数

简单管理系统

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
36
37
38
39
all_workers=[]#存储所有员工信息的列表
while True:
    print('''
        1.信息录入
        2.信息浏览
        3.信息查阅
        4.信息删除
        exit-退出
    ''')
    choice=input("请选择：")
    if choice=='1':
        while True:
           id=int(input("请输入工号："))
           name=input("请输入姓名：")
           age=int(input("请输入年龄："))
           one_worker = [id, name, age]  # 定义一个列表
           all_workers.append(one_worker)#附加--将当前的数据附加到最后
           is_exit=input("是否继续录入(yes/no)?")
           if is_exit=='yes':
                pass
           else:
                break
    elif choice=='2':
        for one in all_workers:
            print("工号：%d,姓名：%s,年龄：%d"%(one[0],one[1],one[2]))
    elif choice=='3':
        name=input("请输入要查找员工的姓名")
        for two in all_workers:
            if name == two[1]:
                print("工号：%d,姓名：%s,年龄：%d"%(two[0],two[1],two[2]))
    elif choice=='4':
        id=int(input("请输入想要删除的员工号："))
        i=0
        for three in all_workers:
            if id==three[0]:
                del all_workers[i]
            i+=1
    if choice=='exit':
        break

日期和时间

python提供了很多方法处理日期和时间，转换日期格式是常见的功能

时间间隔是以秒为单位的浮点小数，每个时间戳都以1970年1月1日午夜经过了多少秒来表示

1
2
3
4
5
6
7
import time;  # 引入time模块
 
ticks = time.time()
print "当前时间戳为:", ticks

结果为：
当前时间戳为: 1459994552.51

获取当前时间

1
2
3
4
5
6
7
import time
 
localtime = time.localtime(time.time())
print "本地时间为 :", localtime

结果为：
本地时间为 : time.struct_time(tm_year=2020, tm_mon=2, tm_mday=28, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

获取格式化的时间

1
2
3
4
5
6
7
import time
 
localtime = time.asctime( time.localtime(time.time()) )
print "本地时间为 :", localtime

结果为
本地时间为 : Feb Apr  7 10:05:21 2020

获取某月日历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import calendar
 
cal = calendar.month(2020, 2)
print("以下输出2020年2月份的日历:")
print(cal)

结果为
   February 2020
Mo Tu We Th Fr Sa Su
                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

Time常用函数

1
2
3
4
5
time.clock()  返回秒数的当前CPU时间

time.time()  返回当时时间戳

time.localtime([secs])  接受时间戳并返回当地时间下的时间元组

函数

定义函数

函数代码块以def关键字开头，后接标识符名称和（）

任何传入的参数和自变量，必须放到()中，在（）中可以定义参数

内容以冒号起始，并且缩进

return 表达式 结束函数，不带return相当于返回None

1
2
3
4
5
6
7
8
9
10
def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]
   
结果为：
def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print(str)
   return

函数调用

直接使用函数名称，加上参数即可

1
2
3
4
5
6
7
8
9
10
11
12
13
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print(str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

结果为：
我要调用用户自定义函数!
再次调用同一函数

参数

分为必备参数，关键字参数，默认参数，不定长参数

必备参数

必须以顺序传入函数，和调用时的数量必须和声明时一致

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print(str)
   return
 
#调用printme函数
printme()

结果为：
Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme()
TypeError: printme() takes exactly 1 argument (0 given)

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值

1
2
3
4
5
6
7
8
9
10
11
12
13
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print("Name: ", name)
   print("Age ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )

结果为：
Name:  miki
Age  50

默认参数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print("Name: ", name)
   print("Age ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )
printinfo( name="miki" )

结果为：
Name:  miki
Age  50
Name:  miki
Age  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print("输出: ")
   print(arg1)
   for var in vartuple:
      print(var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

结果为：
输出:
10
输出:
70
60
50

匿名函数

python使用lambda来创建匿名函数

lambda是一个表达式，比def简单很多

lambda由于简单，所以只能封装有限的逻辑

lambda拥有自己的命名空间

1
2
3
4
5
6
7
8
9
10
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print("相加后的值为 : ", sum( 10, 20 ))
print("相加后的值为 : ", sum( 20, 20 ))

结果为：
相加后的值为 :  30
相加后的值为 :  40

文件I/O

打印到屏幕

1
2
3
4
print("Python 是一个非常棒的语言，不是吗？")

结果为：
Python 是一个非常棒的语言，不是吗？

读取键盘输入

分为raw_input函数和input函数

raw_input函数

函数从标准输入读取一个行，并返回一个字符串

1
2
3
4
5
6
7
8
9
 str = raw_input("请输入：")
print "你输入的内容是: ", str

输入为：
Hello Python！

结果为：
请输入：Hello Python！
你输入的内容是:  Hello Python！

input函数

使用基本类似，但是可以接受一个python表达式作为输入

1
2
3
4
5
6
7
8
9
str = input("请输入：")
print "你输入的内容是: ", str

输入为：
[x*5 for x in range(2,10,2)]

结果为：
请输入：[x*5 for x in range(2,10,2)]
你输入的内容是:  [10, 20, 30, 40]

总结

1.当不知道循环次数时，使用while语句并没和break或continue等控制语句使用，注意避免死循环

2.函数定义时，要注意是否带有参数，如果带有需要用return进行返回，（）中不填则视为无参函数

3.关键字函数，类似于字典中的key，使用键值对的方法来确定变量，相比JAVA和C语言等更加灵活

4.python允许创建匿名函数，但是需要使用lambda关键字，由于使用较为简单，所以只能封装一些简单操作

5.raw_input只能接受一行字符串，input可以接受符合Python语法的表达式进行进一步操作