输出
print( )函数
在输出的数据中加入一个非空白的分隔符
x,y=4,5
print(x,y)
print(x, y, sep=',')
输出
4 5
4,5
换行输出所有数据
x,y=4,5
print(x);print(y)
x,y=4,5
print(x)
print(y)
输出
4
5
将循环输出的数据放在同一行
for i in range(1,5):
print(i,end=' ')
输出
1 2 3 4
列表生成式
遍历一个列表,直接通过元素遍历
L=[4,5,9,7]
for x in L:
print(x)
通过列表下标遍历
L=[4,5,9,7]
for i in range(len(L)):
print(L[i])
输出
4
5
9
7
列表生成式
L=[x*x for x in range(1,5)]
print(L)
lst=[x*x for x in L]
print(lst)
输出
[1, 4, 9, 16]
[1, 16, 81, 256]
在一个列表生成式中，for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else
L=[x*x if x%2==0 else -1 for x in range(1,10)]
print(L)
lst=[x*x for x in range(1,10) if x%2==0]
print(lst)
输出
[-1, 4, -1, 16, -1, 36, -1, 64, -1]
[4, 16, 36, 64]
split()方法语法：
str.split( str="",num=string.count(str))
参数：
- str--分隔符，默认为所有的空字符，包括空格、换行( )、制表符( )等
- num--
分隔次数。默认为-1,即分隔所有
返回值
返回分割后的字符串列表
str='i am a hhhhhh'
print(str.split( ))#默认以空字符分隔
print(str.split('h',1))#以'h'为分隔符,只分割次数是一次
print(str.split('h'))#以'h'为分隔符
#若第二个参数 num 有指定值，则分割为 num+1 个子字符串.其中分隔符相当于一个标记.不会出现在分隔字符串列表中.
输出
['i', 'am', 'a', 'hhhhhh']
['i am a ', 'hhhhh']
['i am a ', '', '', '', '', '', '']
map函数
map(function,iterable)
参数：
- function--函数
- iterable--一个或多个序列
map将传入的函数作用到序列的每个元素，并把结果作为新的Iterator(迭代器)返回
Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的 。
from collections.abc import Iterator#引用库
def powp(x):#定义一个函数
return x*x
L=[1,2,3,4]
r=map(powp,L)
print(isinstance(r,Iterator))#isinstance函数可以判断r是不是迭代器
print(list(r))#将r以列表的形式输出
L=list(r)
print(isinstance(r,Iterator))
print(type(r))
print(type(L))
输出
True
[1, 4, 9, 16]
True
<class 'map'>
<class 'list'>
eval函数
eval(expression[, globals[, locals]])
参数：
- expression-- 表达式.
- globals-- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象.
- locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象 .
返回值：
返回表达式计算结果 .
（返回值就是把最外面的一对双引号或单引号去除了，并且计算出了值）
直接计算一个表达式的值
n=eval(input( ))
print(n)
输入
3.1+5
输出
8.1
输入
"'print'"
输出
'print'
输入
'"hello"'
输出
"hello"
直接输入列表，构造列表
lst=eval(input())
print(type(lst))
print(lst)
输入
[1,2,3,4]
输出
<class 'list'>
[1, 2, 3, 4]
通过input输入的文本数据类型是字符串型,于是可以将其通过规定的分隔符分隔.
n=input( )
print(type(n))
print(n.split())
输入
4 5 6 7
输出
<class 'str'>
['4', '5', '6', '7']
将输入的字符串通过自定义分隔符分隔
n=input( )
print(type(n))
print(n.split('#'))
输入
#123#456789##12
输出
<class 'str'>
['', '123', '456789', '', '12']#列表中的元素全是字符串
将输入的字符串通过自定义分隔符分隔,然后通过map将分隔的每个元素转化int型
n=input( )
print(type(n))
r=map(int,n.split('#'))
print(list(r))
输入
123#456789#12
输出
<class 'str'>
[123, 456789, 12]#列表中的元素是数字
python在一行输入两个整数，其中用空格隔开
a,b=map(int,input().split( ))#其中input()相当于一个字符串被分隔,input().split()返回的是一个字符列表,map将int函数作用在字符列表中的每个元素上.
print(type(a))
print(a)
print(type(b))
print(b)
#输入的数字与变量数量对应,这样可以一一对应.
输入
1 2
输出
<class 'int'>
1
<class 'int'>
2
若读取一行的多个数字，并保存为列表
L=list(map(int,input().split( )))##其中input()相当于一个字符串被分隔,input().split()返回的是一个字符列表,map将int函数作用在字符列表中的每个元素上.然后将map返回的迭代器使用list函数转换成列表并赋值给L
print(L)
输入
1 2 3 4
输出
[1, 2, 3, 4]
lambda
定义一个lambda匿名函数
lambda x: x*x
关键字lambda表示匿名函数，冒号前面的x表示函数参数 ， 返回值就是冒号后面表达式的结果 ， 不用写return
匿名函数是一个函数对象
L=[1,3,5]
lst=list(map(lambda x:x*x,L))
print(lst)
输出
[1, 9, 25]
匿名函数可以赋值给一个变量，再利用变量来调用该函数
powp=lambda x:x*x
L=[1,3,5]
lst=list(map(powp,L))
print(lst)
输出
[1, 9, 25]
利用map()函数和匿名函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字
L1=list(map(str,input( ).split( )))
print(L1)
L2 = list(map(lambda word:word.title( ), L1))
print(L2)
输入
cjf lcb xzh
输出
['cjf', 'lcb', 'xzh']
['Cjf', 'Lcb', 'Xzh']
利用map()函数和匿名函数，把用户输入的不规范的英文名字，全部变成大写
L1=list(map(str,input( ).split( )))
print(L1)
L2 = list(map(lambda word:word.upper( ), L1))
print(L2)
输入
lcb cjf xzh
输出
['lcb', 'cjf', 'xzh']
['LCB', 'CJF', 'XZH']
关键字lambda表示匿名函数，冒号前面的函数参数可以有多个 ， 返回值就是冒号后面表达式的结果 ， 不用写return
def f(x,y):
return (lambda x,y:x+y)(x,y)
print(f(1,2))
print((lambda x,y:x*x+y*y)(1,2))
输出
3
5