Python简单入门到精通_changeone = int(input()) changetwo = int(input())

Python简单入门到精通

朋友推荐，可以自己去动动手

这里我也查了一些资料，整理了一下，感兴趣或者没目标可以看看

其余的都是bilibili上面的可以查到的，手动bilibili-Python

Python基础篇——初体验

Python初体验——Hello World

输出Hello Python

#coding=utf-8

#请在此处添加代码完成输出“Hello Python”,注意要区分大小写！
###### Begin ######
print("Hello Python")
###### End ######
1
2
3
4
5
6

我想看世界

#coding=utf-8

#请在此处补充代码，按要求完成输出
###### Begin ######
name=input("请输入一个人的名字：")
country=input("请输入一个国家的名字：")
print("世界那么大，{}想去{}看看。".format(name,country))
###### End ######
1
2
3
4
5
6
7
8

学好Python

#coding=utf-8

#请在此处补充代码，按要求完成输出
###### Begin ######
name=input("输入姓名：")
print("{}同学，学好Python，前途无量！".format(name ))     #请将命令行补充完整
print("{}大侠，学好Python，大展拳脚！".format(name[0]) )  #请将命令行补充完整
print("{}哥哥，学好Python，人见人爱！".format(name[1:]) ) #请将命令行补充完整
###### End ######
1
2
3
4
5
6
7
8
9

Python入门之基础语法

行与缩进

#有错误的函数1
#Python 的代码一般是一行一条语句，语句之后的分号 ; 可加可不加。但如果要在一行中写多条语句，则需要用分号 ; 隔开每条语句。
def wrong1():
   print("wrong1")
    #print("这里有一个错误缩进")这个程序的 if 部分缩进不相同，所以是错误的程序。
   print("这里有一个错误缩进")
    
#有错误的函数2
def wrong2():
    print("wrong2")
    if False:
        print("这个不应该输出")
        print("这个也不应该输出")

#有错误的函数3
#Python 的代码一般是一行一条语句，语句之后的分号 ; 可加可不加。但如果要在一行中写多条语句，则需要用分号 ; 隔开每条语句。
def wrong3():
    print("wrong3"); print("hello world");


#这里是调用三个函数的代码
#不要修改
if __name__ == '__main__':

    wrong1()
    wrong2()
    wrong3()
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

标识符与保留字

• 标识符

第一个字符必须是字母表中的字母或下划线 _ ；
标识符的其他的部分，由字母、数字和下划线组成；
标识符对大小写敏感；
标识符不能与保留字相同。
1
2
3
4

num1 = 1
float1 = 0.5
true = True #这个 true 虽然字面上的意思与值“True”相同，但 python 对大小写敏感，所以也是正确的
str1 = "hello"
1
2
3
4

num1 = 1
float1 = 0.5
true = True #这个 true 虽然字面上的意思与值“True”相同，但 python 对大小写敏感，所以也是正确的
str1 = "hello"
1
2
3
4

测试

import keyword

if __name__ == '__main__':
    #错误1
    str1 = "string"
    print(str1)

    #错误2
    num = 1024
    print(num)

    #错误3
    float_1 = 1.024
    print(float_1)

    #错误3
    false = False
    print(False)

    #在此处输出保留关键字
    print(keyword.kwlist)
    print("end")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

注释

• 注释

#使用多个#
#作注释
'''
用三个单引号
作注释
'''
"""
用三个双引号
作注释
"""
1
2
3
4
5
6
7
8
9
10

测试

if __name__ == '__main__':


    #以下是要修改的代码

    print(1)
    #print(2)
    print(3)
    #print(4)
    print(5)
    #print(6)

    """
    print("hello world")
    print("这个不应该输出")
    """ 
    print("hello world")

    #print(1)
    #print(2)
    print(3)
    print(4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输入输出

• 格式字符串中，不同占位符的含义：

%s：      作为字符串
%d：     作为有符号十进制整数
%u：     作为无符号十进制整数
%o：     作为无符号八进制整数
%x：     作为无符号十六进制整数，a～f采用小写形式
%X：     作为无符号十六进制整数，A～F采用大写形式
%f：     作为浮点数
%e，%E： 作为浮点数，使用科学计数法
%g，%G： 作为浮点数，使用最低有效数位
1
2
3
4
5
6
7
8
9

如果不想换行，需要指定end=""

print("hello" , end="")
print("world" , end="")
# 输出结果：helloworld
1
2
3

测试

if __name__ == "__main__":
    a = int(input())
    b = int(input())
# ********** Begin ********** #
    print("%d + %d = %d" %(a,b,a + b))
    print("%d - %d = %d" %(a,b,a - b))
    print("%d * %d = %d" %(a,b,a * b))
    print("%d / %d = %f" %(a,b,a / b))
# ********** End ********** #
1
2
3
4
5
6
7
8
9

Python基础篇——基本数据类型

Python 入门之字符串处理

字符串的拼接：名字的组成

# coding=utf-8

# 存放姓氏和名字的变量
first_name = input()
last_name = input()

# 请在下面添加字符串拼接的代码，完成相应功能
########## Begin ##########
result_string = first_name + " " + last_name
print(result_string)
########## End ##########
1
2
3
4
5
6
7
8
9
10
11

字符转换

# coding=utf-8
# 创建一个字符串say_hello
say_hello = 'Dear my Daughter'
# 使用upper()方法对say_hello字符串进行处理
upper_say_hello = say_hello.upper()
# 使用lower()方法对say_hello字符串进行处理
lower_say_hello = say_hello.lower()
# 使用title()方法对say_hello字符串进行处理
title_say_hello = say_hello.title()
# 打印输出四个字符串
print (say_hello+"\n")#Dear my Daughter
print (upper_say_hello+"\n")#DEAR MY DAUGHTER
print (lower_say_hello+"\n")#dear my daughter
print (title_say_hello+"\n")#Dear My Daughter
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试

# coding=utf-8

# 获取待处理的源字符串
source_string = input()

# 请在下面添加字符串转换的代码
########## Begin ##########
blank = source_string.strip()
blank_title = blank.title()
print(blank_title)
print(len(blank_title))
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12

字符串查找与替换

# coding = utf-8
source_string = input()

# 请在下面添加代码
########## Begin ##########
print(source_string.find('day'))
print(source_string.replace('day','time'))
print(source_string.replace('day','time').split(' '))
########## End ##########
1
2
3
4
5
6
7
8
9

Python 入门之玩转列表

客人名单的变化

在列表尾部添加元素：append()
在列表指定位置添加元素：insert()
修改列表元素：source_list[index] = obj
删除列表元素：
1.del方法 del source_list[index]
2.pop方法 deleted_obj = source_list.pop(index)
删除指定值对应的元素：remove()
1
2
3
4
5
6
7

测试

# coding=utf-8

# 创建并初始化Guests列表
guests = []
while True:
	try:
		guest = input()
		guests.append(guest)
	except:
		break

	
# 请在此添加代码，对guests列表进行插入、删除等操作
########## Begin ##########
guest = guests.pop(4)
print(guest)
guests.insert(1,'hu ba')
del guests[2]
print(guests)
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

给客人排序

排序 sort() source_list.sort(reverse=True)
#reverse：sort函数的可选参数。如果设置其值为True，则进行反向从大到小排序，如果设置为False或者不填写该参数，则默认进行正向从小到大排序。
1
2

测试

# coding=utf-8

# 创建并初始化`source_list`列表
source_list = []
while True:
    try:
        list_element = input()
        source_list.append(list_element)
    except:
        break
    
# 请在此添加代码，对source_list列表进行排序等操作并打印输出排序后的列表
########## Begin ##########
source_list.sort()
print(source_list)
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

用数字说话

range()函数：range(lower_limit,upper_limit,step)
lower_limit: 生成系列整数的下限整数，不填该参数则默认为从0开始，生成的整数从此数开始，包括该数；

upper_limit：生成系列整数的上限整数，必填参数，生成的整数要小于该上限；

step：在下限和上限之间生成系列整数之间的间隔步长，不填该参数则默认步长为1。

注意：range()函数的三个参数都只能为整数。如果range()函数中仅一个参数，则该参数表示upper_limit，如果仅
两个参数，则分别表示lower_limit和upper_limit。

使用list()函数和range()函数创建数字列表
data_list = list(range(lower_limit,upper_limit,step))
1
2
3
4
5
6
7
8
9
10
11
12

测试

# coding=utf-8

# 创建并读入range函数的相应参数
lower = int(input())
upper = int(input())
step = int(input())

# 请在此添加代码，实现编程要求
########## Begin ##########
source_list = list(range(lower,upper,step))
length = len(source_list)
print(length)
max_list = max(source_list)
min_list = min(source_list)
print(max_list-min_list)
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

你的菜单和我的菜单

切片 list_slice = source_list[start:end:step]
负数索引返回的是离列表末尾相应间隔的元素，列表末尾元素的索引是从-1开始的。
1
2

测试

# coding=utf-8

# 创建并初始化my_menu列表
my_menu = []
while True:
	try:
		food = input()
		my_menu.append(food)
	except:
		break

# 请在此添加代码，对my_menu列表进行切片操作
########## Begin ##########
print(my_menu[0:5:3])
print(my_menu[-3:])
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Python 入门之元组与字典

这份菜单能修改吗？

元组与列表很相似，两者之间的差别在于：

▶列表在初始化后其中的元素还可以进行增删改等操作，但是元组在初始化后其中的元素不能进行更改；
▶列表在赋值时使用方括号[]，而元组在赋值时使用小括号()。
因为元组具有不可变的特性，所以在能用元组替代列表的地方最好都使用元组，这样代码更安全。
元组和列表一样，都有一些内置函数方便编程。例如：

len(tuple)：计算元组中元素个数；

max(tuple)：返回元组中元素的最大值；

min(tuple)：返回元组中元素的最小值；

tuple(seq)：将列表转换为元组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试

# coding=utf-8

# 创建并初始化menu_list列表
menu_list = []
while True:
	try:
		food = input()
		menu_list.append(food)
	except:
		break

# 请在此添加代码，对menu_list进行元组转换以及元组计算等操作，并打印输出元组及元组最大的元素
###### Begin ######
print(tuple(menu_list))
print(max(tuple(menu_list)))
#######  End #######
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这份菜单可以修改

# coding=utf-8

# 创建并初始化menu_dict字典
menu_dict = {}
while True:
	try:
		food = input()
		price = int(input())
		menu_dict[food]= price
	except:
		break

# 请在此添加代码，实现对menu_dict的添加、查找、修改等操作，并打印输出相应的值
########## Begin ##########
print(menu_dict['fish'])
menu_dict['fish'] = 100
del menu_dict['noodles']
menu_dict['lamb'] = 50
print(menu_dict)
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

菜名和价格的展示

遍历字典中的键-值对
Python 为字典类型提供了items()方法，items()方法会将字典里的所有的键与值一起返回。

# coding = utf-8
# 创建并初始化menu菜单字典
menu={'fish':'40','pork':'30','potato':'20','lamb':'50'}
# 利用items()方法遍历输出键和值
for key,value in menu.items():
    print('\nkey:'+key)
    print('value:'+value)
1
2
3
4
5
6
7
8
9
10

测试

# coding=utf-8

# 创建并初始化menu_dict字典
menu_dict = {}
while True:
	try:
		food = input()
		price = int(input())
		menu_dict[food]= price
	except:
		break

# 请在此添加代码，实现对menu_dict的遍历操作并打印输出键与值
########## Begin ##########
for key in menu_dict.keys():
    print(key)
for value in menu_dict.values():
    print(value)
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

嵌套 - 菜单的信息量好大

# coding=utf-8

# 初始化menu1字典，输入两道菜的价格
menu1 = {}
menu1['fish']=int(input())
menu1['pork']=int(input())

# menu_total列表现在只包含menu1字典
menu_total = [menu1]

# 请在此添加代码，实现编程要求
########## Begin ##########
menu2 = menu1.copy()
for key in menu2.keys():
    menu2[key] = menu2[key] * 2
menu_total.append(menu2)
########## End ##########

# 输出menu_total列表
print(menu_total)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Python入门之collections模块

命名元组 (namedtuple)

创建命名元组
命名元组的构造函数接受两个参数typename，field_names：

typename：元组的名字；
field_names：元组各个元素的名称，也就是属性名称。
collections.namedtuple("Point",["x","y"])
1
2
3
4
5
6

测试

• 注意缩进

import collections

def CreatePoint():
    # ********** Begin ********** #
 p=collections.namedtuple("p","x,y")
 p=p(x=0,y=0)
 return p
	# ********** End ********** #

def IncX(p):
    # ********** Begin ********** #
 p=p._replace(x=1)
 return p
	# ********** End ********** #

def IncY(p):
    # ********** Begin ********** #
 p=p._replace(y=1)
 return p
	# ********** End ********** #

def PrintPoint(p):
    print("当前位置:x = %d,y = %d" % p)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

计数器 (Counter)

import collections
def Func():
    c = collections.Counter()
    for i in range(6):
        data = input()
        # ********** Begin ********** #
        if(i%2==0):
            c.update(data)
        else:
            c.subtract(data)
        # ********** End ********** #
    print(c.most_common())
1
2
3
4
5
6
7
8
9
10
11
12

双向队列 (deque)

import collections
def Func():
    d = collections.deque()
    n = int(input())
    # ********** Begin ********** #
    for i in range(n):
        if(i%2!=0):
            d.appendleft(i)
        else:
            d.append(i)
    # ********** End ********** #
    print(d)
1
2
3
4
5
6
7
8
9
10
11
12

有序字典 (OrderedDict)

import collections
def Func():
    pairs = []
    n = int(input())
    for s in range(n):
        k = input()
    # ********** Begin ********** #
        pairs.append((k,s))
    od = collections.OrderedDict(sorted(pairs,key=lambda s:s[0]))
    # ********** End ********** #
    print(od)
1
2
3
4
5
6
7
8
9
10
11

默认字典 (defaultdict)

• 有些难度

import collections

def GetIntDefaultDict():
    #返回一个空的int类型的默认字典
    # ********** Begin ********** #
    dd = collections.defaultdict(int)
    return dd
    print("int默认字典的默认值：",dd['a'])
    # ********** End ********** #

def GetListDefaultDict():
    #返回一个空的list类型的默认字典
    # ********** Begin ********** #
    dd = collections.defaultdict(list)
    return dd
    print("list默认字典的默认值：",dd['a'])
    # ********** End ********** #

def GetTupleDefaultDict():
    #返回一个空的tuple类型的默认字典
    # ********** Begin ********** #
    dd = collections.defaultdict(tuple)
    return dd
    print("tuple默认字典的默认值：",dd['a'])
    # ********** End ********** #

def GetStrDefaultDict(): 
    #返回一个空的str类型的默认字典
    # ********** Begin ********** #
    dd = collections.defaultdict(str)
    return dd
    print("str默认字典的默认值：",dd['a'])
    # ********** End ********** #
GetIntDefaultDict()
GetListDefaultDict()
GetTupleDefaultDict()
GetStrDefaultDict()
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

Python零基础到精通之：Python基础篇

Python 入门之函数结构

函数的参数 - 搭建函数房子的砖

函数的基本定义：
def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]
定义函数以def关键词开头，后面跟着函数名、圆括号()、括号中的参数、冒号；
接着，在缩进块中编写函数体，函数的第一行语句一般是写文档字符串，用于存放函数说明，也可以选择不写；
Return[expression]表示结束函数，并返回值。而不带表达式的return相当于返回空值。

Python 的函数参数主要包含以下几种：
必选参数；
默认参数；
可变参数；
关键字参数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试

# coding=utf-8

# 创建一个空列表numbers
numbers = []

# str用来存储输入的数字字符串，lst1是将输入的字符串用空格分割，存储为列表
str = input()
lst1 = str.split(' ')

# 将输入的数字字符串转换为整型并赋值给numbers列表
for i in range(len(lst1)):
   numbers.append(int(lst1.pop()))

# 请在此添加代码，对输入的列表中的数值元素进行累加求和
########## Begin ##########
def plus(numbers):
    add = 0
    for i in numbers:
        add += i
    return(add)
d = plus(numbers)
########## End ##########

print(d)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

函数的返回值 - 可有可无的 return

# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input())

# 请在此添加代码，求两个正整数的最大公约数
########## Begin ##########
def gcd(a,b):
    if a<b:
        x=a
    else:
        x=b 
    for i in range(1,x+1):
        if a%i==0 and b%i==0:
            res=i
    return res
########## End ##########

# 调用函数，并输出最大公约数
print(gcd(a,b))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

函数的使用范围：Python 作用域

# coding=utf-8

# 输入两个正整数a,b
a = int(input())
b = int(input())

# 请在此添加代码，求两个正整数的最小公倍数
########## Begin ##########
def lcm(a,b):
    if(a > b):
        greater = a
    else:
        greater = b

    while(True):
        if((greater % a == 0) and (greater % b == 0)):
            lcm = greater
            break
        greater =greater + 1
    return lcm
########## End ##########

# 调用函数，并输出a,b的最小公倍数
print(lcm(a,b))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Python 入门之控制结构 - 循环结构

While 循环与 break 语句

partcount = int(input())
electric = int(input())
count = 0
#请在此添加代码，当count < partcount时的while循环判断语句
#********** Begin *********#
while(count<partcount):
#********** End **********#
    count += 1
    print("已加工零件个数:",count)
    if(electric):
        print("停电了，停止加工")
        #请在此添加代码，填入break语句
        #********** Begin *********#
        break
        #********** End **********#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

for 循环与 continue 语句

absencenum = int(input())
studentname = []
inputlist = input()
for i in inputlist.split(','):
   result = i
   studentname.append(result)
count = 0
#请在此添加代码，填入循环遍历studentname列表的代码
#********** Begin *********#
for student in studentname:
#********** End **********#
    count += 1
    if(count == absencenum):
        #在下面填入continue语句
        #********** Begin *********#
        continue
        #********** End **********#
    print(student,"的试卷已阅")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

循环嵌套

studentnum = int(input())
#请在此添加代码，填入for循环遍历学生人数的代码
#********** Begin *********#
for student in range(studentnum):
#********** End **********#
    sum = 0
    subjectscore = []
    inputlist = input()
    for i in inputlist.split(','):
        result = i
        subjectscore.append(result)
    #请在此添加代码，填入for循环遍历学生分数的代码
    #********** Begin *********#
    for score in subjectscore:
    #********** End **********#
        score = int(score)
        sum = sum + score
    print("第%d位同学的总分为:%d" %(student,sum))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

迭代器

可直接作用于for循环的数据类型如list、tuple、dict等统称为可迭代对象:Iterable。使用isinstance()可以判断一个对象是否是可迭代对象。
from collections import Iterable
result = isinstance([],Iterable)
print(result)#True
result = isinstance((),Iterable)
print(result)#True
result = isinstance('python',Iterable)
print(result)#True
result = isinstance(213,Iterable)
print(result)#False
可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。next()函数访问每一个对象，直到对象访问完毕，返回一个StopIteration异常。使用isinstance()可以判断一个对象是否是Iterator对象。
from collections import Iterator
result = isinstance([],Iterator)
print(result)#False
result = isinstance((),Iterator)
print(result)#False
result = isinstance((x for x in range(10)),Iterator)
print(result)#True
当自己定义迭代器时，需要定义一个类。类里面包含一个iter()函数，这个函数能够返回一个带next()方法的对象。
class MyIterable:
    def __iter__(self):
        return MyIterator()
class MyIterator:
    def __init__(self):
        self.num = 0
    def __next__(self):
        self.num += 1
        if self.num >= 10:
            raise StopIteration
        return self.num
迭代器当一次迭代完毕后就结束了，在此调用便会引发StopIteration异常。如果想要将迭代器保存起来，可以使用复制的方法:copy.deepcopy():x = copy.deepcopy(y)，不可使用赋值的方法，这样是不起作用的。
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

测试（next？）

List = []
member = input()
for i in member.split(','):
    result = i
    List.append(result)
#请在此添加代码，将List转换为迭代器的代码
#********** Begin *********#
n = iter(List)
#********** End **********#
while True:
    try:
        #请在此添加代码，用next()函数遍历IterList的代码
        #********** Begin *********#
        num=next(n)
        #********** End **********#
        result = int(num) * 2
        print(result)
    except StopIteration:
        break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Python 入门之控制结构 - 顺序与选择结构

顺序结构

changeOne = int(input())
changeTwo = int(input())
plus = int(input())

# 请在此添加代码，交换changeOne、changeTwo的值，然后计算changeOne、plus的和result的值
########## Begin ##########
changeOne = changeTwo
result = plus+changeOne
########## End ##########
print(result)
1
2
3
4
5
6
7
8
9
10

选择结构：if-else

workYear = int(input())
# 请在下面填入如果workYear < 5的判断语句
########## Begin ##########
if workYear < 5:
########## End ##########
    print("工资涨幅为0")
# 请在下面填入如果workYear >= 5 and workYear < 10的判断语句
########## Begin ##########
elif workYear >= 5 and workYear < 10:#elif或if都行
########## End ##########
    print("工资涨幅为5%")
# 请在下面填入如果workYear >= 10 and workYear < 15的判断语句
########## Begin ##########
elif workYear >= 10 and workYear < 15:#elif或if都行
########## End ##########
    print("工资涨幅为10%")
# 请在下面填入当上述条件判断都为假时的判断语句
########## Begin ##########
else:
########## End ##########
    print("工资涨幅为15%")
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

选择结构 ： 三元操作符

jimscore = int(input())
jerryscore = int(input())
# 请在此添加代码，判断若jim的得分jimscore更高，则赢家为jim，若jerry的得分jerryscore更高，则赢家为jerry，并输出赢家的名字
########## Begin ##########
winner = 'jim' if jerryscore < jimscore else 'jerry'
########## End ##########
print(winner)
1
2
3
4
5
6
7

Python入门之函数调用

内置函数 - 让你偷懒的工具

abs()：返回数值的绝对值
divmod()：返回两个数值的商和余数
max()：返回元素中的最大值
min()：返回元素中的最小值
sum()：返回传入元素之和
bool()：根据传入的参数的逻辑值创建一个新的布尔值
int()：根据传入的参数创建一个新的整数
float()：根据传入的参数创建一个新的浮点数
complex()：根据传入的参数创建一个新的复数
all()：判断可迭代对象的每个元素是否都为True值
any()：判断可迭代对象的元素是否有为True值的元素
sorted()：对可迭代对象进行排序，返回一个新的列表
help()：返回对象的帮助信息
dir()：返回对象或者当前作用域内的属性列表
print()：向标准输出对象打印输出
input()：读取用户输入值
open()：使用指定的模式和编码打开文件，返回文件读写对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

测试

# coding=utf-8

# 输入一个整数n
n =  int(input())

# 请在此添加代码，对输入的整数进行判断，如果是素数则输出为True，不是素数则输出为False
########## Begin ##########
def prime(n):
    if n <3 :
        return False
    for i in range(2,n):
        if n%i==0:
            return False
            break
    else:
        return True
########## End ##########
print(prime(n))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

函数正确调用 - 得到想要的结果

# coding=utf-8

# 输入数字字符串，并转换为数值列表
a = input()
num1 = eval(a)
numbers = list(num1)

# 请在此添加代码，对数值列表numbers实现从小到大排序
########## Begin ##########
def num(a):
    numbers.sort()
    return numbers
print(num(num1))
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14

函数与函数调用 - 分清主次

# coding=utf-8

from math import pi as PI

n = int(input())

# 请在此添加代码，实现圆的面积计算，并输出面积结果
########## Begin ##########
def area(n):
    return (pow(n,2)*PI)
#print('%.2f'%area(n))
print(round(area(n),2))
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13

Python入门之模块

模块的定义

# coding=utf-8

import math

# 输入正整数a和b
a = float(input())
b = float(input())

# 请在此添加代码，输入直角三角形的两个直角边的边长a和b，计算出其斜边边长
########## Begin ##########
c=math.sqrt(a*a+b*b)
print('%.3f'%c)
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13

内置模块中的内置函数

 Python 中常见的内置模块如下：

os模块：文件和目录，用于提供系统级别的操作；
sys模块：用于提供对解释器相关的操作；
json模块：处理JSON字符串；
logging: 用于便捷记录日志且线程安全的模块；
time&datetime模块：时间相关的操作，时间有三种表示方式；
hashlib模块：用于加密相关操作，代替了md5模块，主要是提供SHA1、SHA224、SHA256、SHA384、SHA512和MD5算法；
random模块：提供随机数。
1
2
3
4
5
6
7
8
9

测试

# coding=utf-8

# 导入math模块
import math

# 输入两个整数a和b
a = int(input())
b = int(input())

# 请在此添加代码，要求判断是否存在两个整数，它们的和为a，积为b
########## Begin ##########
for i in range(1,abs(b)+1):
    k=b/i
    if(math.ceil(k)==k and k+i==a):
        print('Yes')
        break
else:
    print('No')
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Python 入门之经典函数实例

递归函数 - 汉诺塔的魅力

# coding=utf-8

# 输入正整数n
n = int(input())

# 请在此添加代码，对输入的正整数n进行阶乘运算，并输出计算结果。
########## Begin ##########
def fact(n):
    sum = 0
    if(n<1):
        sum = 1
    else:
        sum = n*fact(n-1)
    return (sum)
print(fact(n))
########## End ##########
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

lambda 函数 - 匿名函数的使用

# coding=utf-8

# 请在此添加代码，使用lambda来创建匿名函数，能够判断输入的两个数值的大小
########## Begin ##########
MAXIMUM = lambda a,b:a if a>b else b
MINIMUM = lambda a,b:a if a<b else b
########## End ##########

# 输入两个正整数
a = int(input())
b = int(input())

# 输出较大的值和较小的值
print('较大的值是：%d' % MAXIMUM(a,b))
print('较小的值是：%d' % MINIMUM(a,b))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Map-Reduce - 映射与归约的思想

# coding=utf-8

# 输入一个正整数
x = int(input())

# 请在此添加代码，将输入的一个正整数分解质因数
########## Begin ##########
import math as mt
result = []
num = x
def dg_num(num):
    if num==1:
        return 0
    else:
        for i in range(int(mt.sqrt(num))-1):
            if num%(i+2)==0:
                result.append(i+2)
                num = num//(i+2)
                return dg_num(num)
        result.append(num)
dg_num(num)
########## End ##########

# 输出结果，利用map()函数将结果按照规定字符串格式输出
print(x,'=','*'.join(map(str,result)))
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

Python基础之综合练习一

最小公倍数算法

1

输出指定范围内的素数

1

Python对文件的操作

1

Python基础之综合练习二

素数判断

1

九九乘法表

1

简单计算器

1

Python进阶篇——面向对象

Python 入门之类的基础语法

类的声明与定义

# 请在下面填入定义Book类的代码
########## Begin ##########
class Book(object):
########## End ##########
    '书籍类'
    def __init__(self,name,author,data,version):
        self.name = name
        self.author = author
        self.data = data
        self.version = version

    def sell(self,bookName,price):
        print("%s的销售价格为%d" %(bookName,price))
1
2
3
4
5
6
7
8
9
10
11
12
13

类的属性与实例化

类的数据属性
类的数据属性只与类绑定，不属于任何实例。在类创建后，属性也被创建，类的数据属性也可以称为静态变量，它通常用来跟踪与类相关的值。类的数据属性使用的并不多，一般都是用实例数据属性

类中还有很多特殊属性，具体如下:

ClassName.__name__：类ClassName的名字；
ClassName.__doc__：类ClassName的文档字符串；
ClassName.__bases__：类ClassName的所有父类构成的元组；
ClassName.__dict__：类ClassName的属性；
ClassName.__module__：类ClassName定义所在的模块；
Instance.__class__：实例Instance所对应的类。
1
2
3
4
5
6
7
8
9
10
11

测试

class People:
    # 请在下面填入声明两个变量名分别为name和country的字符串变量的代码
    ########## Begin ##########
    #不会，但是不影响运行
    ########## End ##########
    def introduce(self,name,country):
        self.name = name
        self.country = country
        print("%s来自%s" %(name,country))
name = input()
country = input()
# 请在下面填入对类People进行实例化的代码，对象为p
########## Begin ##########
p = People()
########## End ##########
p.introduce(name,country)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

绑定与方法调用

import fractionSumtest
# 请在下面填入创建fractionSum的实例fs的代码
########## Begin ##########
f = fractionSumtest.fractionSum()
########## End ##########
n = int(input())
if n % 2 == 0:
    # 请在下面填入调用fractionSumtest类中dcall方法的代码，计算当n为偶数时计算的和
    ########## Begin ##########
    sum = f.dcall(f.peven,n)
    ########## End ##########
else:
    # 请在下面填入调用fractionSumtest类中dcall方法的代码，计算当n为奇数时计算的和
    ########## Begin ##########
    sum = f.dcall(f.podd,n)
    ########## End ##########
print(sum)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

静态方法与类方法

class BookSell:
    static_var = 100
    def sell(self,name,author,version,price):
        print("%s的销售价格为%d" %(name,int(price)))
    # 请在下面填入函数修饰符将printStatic()方法声明为静态方法
    ########## Begin ##########
    @staticmethod
    ########## End ##########
    def printStatic():
        print(BookSell.static_var)
    # 请在下面填入函数修饰符将printVersion(cls)方法声明为类方法
    ########## Begin ##########
    @classmethod
    ########## End ##########
    def printVersion(cls):
        print(cls)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

类的导入

# 从 DataChangetest 模块中导入 DataChange 类，并使用该类中的 eightToten(self,p) 方法，实现将输入的八进制转换成十进制输出。
########## Begin ##########
from DataChangetest import DataChange
num = DataChange()
p = input()
num.eightToten(p)
########## End ##########
1
2
3
4
5
6
7

Python 入门之类的继承

初识继承

import animalstest
#from animalstest import animals #方法二
# 请在下面填入定义fish类的代码，fish类继承自animals类
########## Begin ###########
class fish(animalstest.animals):#方法一
########## End ##########
    def __init__(self,name):
        self.name = name
    def swim(self):
        print("%s会游泳" %self.name)

# 请在下面填入定义leopard类的代码，leopard类继承自animals类
########## Begin ##########
class leopard(animalstest.animals):#方法一
########## End ##########
    def __init__(self,name):
        self.name = name
    def climb(self):
        print("%s会爬树" %self.name)

fName = input()
lName = input()
f = fish(fName)
f.breath()
f.swim()
f.foraging()
l = leopard(lName)
l.breath()
l.run()
l.foraging()
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

覆盖方法

1

从标准类派生

1

多重继承

1

Python 入门之类的其它特性

Python面向对象编程实训

Python面向对象编程综合运用

Python零基础到精通之：Python进阶篇

Python 正则表达式

Python 计算思维训练——文件操作与异常处理

Python堆栈与队列

Python 迭代器与生成器

Python 数据解析：JSON与XML

Python–进程和线程

常用占位符含义

s : 获取传入对象的__str__方法的返回值，并将其格式化到指定位置

r : 获取传入对象的__repr__方法的返回值，并将其格式化到指定位置

c : 整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置

o : 将整数转换成 八  进制表示，并将其格式化到指定位置

x : 将整数转换成十六进制表示，并将其格式化到指定位置

d : 将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置

e : 将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）

E : 将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）

f :  将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）

F : 同上

g : 自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）

G : 自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）

% : 当字符串中存在格式化标志时，需要用 %%表示一个百分号;
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