文章目录
输入输出
输入 input()
input(prompt=None, /)
Read a string from standard input. The trailing newline is stripped.
The prompt string, if given, is printed to standard output without a
trailing newline before reading input.
If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
On *nix systems, readline is used if available.
输出 print()
-
print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
-
Prints the values to a stream, or to sys.stdout by default.
-
Optional keyword arguments:
- file: a file-like object (stream); defaults to the current sys.stdout.
- sep: string inserted between values, default a space.
- end: string appended after the last value, default a newline.
- flush: whether to forcibly flush the stream.
标准输入输出, 行读入
python3 中 raw_input() 已废弃
# 1.输入多行,a是一个多行字符串
import sys
a = sys.stdin.read()
print(a)
# 2.输入多行,a是一个列表,列表中每一个元素对应字符串的一行,行末的\n也还在
import sys
a = sys.stdin.readlines()
print(a)
# 或者
import sys
for line in sys.stdin.readlines():
print(line.strip())
# 3.输入单行,a直接就是那一行字符串
import sys
a = sys.stdin.readline()
print(a)
基础语法
六个标准数据类型
- 不可变数据:
- Number(数字)
- String(字符串)
- Tuple(元组)
- 可变数据:
- List(列表)
- Set(集合)
- Dictionary(字典)
Number ( 数字 )
Number 分为 int, float, complex, bool
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
数学函数
函数 | 返回值 ( 描述 ) |
---|---|
abs(x) | 返回数字的绝对值,如abs(-10) 返回 10 |
ceil(x) | 返回数字的上入整数,如math.ceil(4.1) 返回 5 |
cmp(x, y) |
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃,使用 (x>y)-(x<y) 替换。 |
exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
fabs(x) | 返回数字的绝对值,如math.fabs(-10) 返回10.0 |
floor(x) | 返回数字的下舍整数,如math.floor(4.9)返回 4 |
log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
log10(x) | 返回以10为基数的x的对数,如math.log10(100)返回 2.0 |
max(x1, x2,...) | 返回给定参数的最大值,参数可以为序列。 |
min(x1, x2,...) | 返回给定参数的最小值,参数可以为序列。 |
modf(x) | 返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。 |
pow(x, y) | x**y 运算后的值。 |
round(x [,n]) | 返回浮点数 x 的四舍五入值,如给出 n 值,则代表舍入到小数点后的位数。 其实准确的说是保留值将保留到离上一位更近的一端。 |
sqrt(x) | 返回数字x的平方根。 |
随机数函数
函数 | 描述 |
---|---|
choice(seq) | 从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。 |
randrange ([start,] stop [,step]) | 从指定范围内,按指定基数递增的集合中获取一个随机数,基数默认值为 1 |
random() | 随机生成下一个实数,它在[0,1)范围内。 |
seed([x]) | 改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。 |
shuffle(lst) | 将序列的所有元素随机排序 |
uniform(x, y) | 随机生成下一个实数,它在[x,y]范围内。 |
三角函数
函数 | 描述 |
---|---|
acos(x) | 返回x的反余弦弧度值。 |
asin(x) | 返回x的反正弦弧度值。 |
atan(x) | 返回x的反正切弧度值。 |
atan2(y, x) | 返回给定的 X 及 Y 坐标值的反正切值。 |
cos(x) | 返回x的弧度的余弦值。 |
hypot(x, y) | 返回欧几里德范数 sqrt(x*x + y*y)。 |
sin(x) | 返回的x弧度的正弦值。 |
tan(x) | 返回x弧度的正切值。 |
degrees(x) | 将弧度转换为角度,如degrees(math.pi/2) , 返回90.0 |
radians(x) | 将角度转换为弧度 |
数学常量
常量 | 描述 |
---|---|
pi | 数学常量 pi(圆周率,一般以π来表示) |
e | 数学常量 e,e即自然常数(自然常数)。 |
String ( 字符串 )
# string 测试
s = "PythonStudy"
print( s )
print( s[0:-1] )
print( s[0] )
print( s[2:5] )
print( s*2 )
print( s[::2] ) # 第二个冒号之后是步长
print( s+"_Test" )
print( "\n__________________转义test\n" )
print( "Hello \nPython!" )
print( r"Hello \nPython" )
print( "\n__________________转义test\n" )
>>> # string 测试
... s = "PythonStudy"
>>> print( s )
PythonStudy
>>> print( s[0:-1] ) # 输出第一个到倒数第二个的所有字符
PythonStud
>>> print( s[0] )
P
>>> print( s[2:5] ) # 输出从第三个开始到第五个的字符
tho
>>> print( s*2 ) # 输出字符串两次
PythonStudyPythonStudy
>>> print( s[::2] )
PtoSuy
>>> print( s+"_Test" )
PythonStudy_Test
>>> print( "\n__________________转义test\n" )
__________________转义test
>>> print( "Hello \nPython!" ) # 使用反斜杠(\)+n转义特殊字符
Hello
Python!
>>> print( r"Hello \nPython" ) # 在字符串前面添加一个 r,表示原始字符串,不会发生转义
Hello \nPython
>>> print( "\n__________________转义test\n" )
函数
序号 | 方法及描述 |
---|---|
1 | capitalize() |
2 | 返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。 |
3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
4 | bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。 |
5 | encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace' |
6 | endswith(suffix, beg=0, end=len(string)) |
7 | 把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。 |
8 | find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1 |
9 | index(str, beg=0, end=len(string)) 跟find()方法一样,只不过如果str不在字符串中会报一个异常. |
10 | 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
11 | 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
12 | 如果字符串只包含数字则返回 True 否则返回 False.. |
13 | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False |
14 | 如果字符串中只包含数字字符,则返回 True,否则返回 False |
15 | 如果字符串中只包含空白,则返回 True,否则返回 False. |
16 | 如果字符串是标题化的(见 title())则返回 True,否则返回 False |
17 | 如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False |
18 | 以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
19 | 返回字符串长度 |
20 | 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。 |
21 | 转换字符串中所有大写字符为小写. |
22 | 截掉字符串左边的空格或指定字符。 |
23 | 创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。 |
24 | 返回字符串 str 中最大的字母。 |
25 | 返回字符串 str 中最小的字母。 |
26 | 把 将字符串中的 str1 替换成 str2,如果 max 指定,则替换不超过 max 次。 |
27 | rfind(str, beg=0,end=len(string)) 类似于 find()函数,不过是从右边开始查找. |
28 | rindex( str, beg=0, end=len(string)) 类似于 index(),不过是从右边开始. |
29 | 返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串 |
30 | 删除字符串字符串末尾的空格. |
31 | split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num+1 个子字符串 |
32 | 按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。 |
33 | startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。 |
34 | 在字符串上执行 lstrip()和 rstrip() |
35 | 将字符串中大写转换为小写,小写转换为大写 |
36 | 返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle()) |
37 | translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
38 | 转换字符串中的小写字母为大写 |
39 | 返回长度为 width 的字符串,原字符串右对齐,前面填充0 |
40 | 检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。 |
Tuple( 元组 )
一旦创建不可修改
>>> myTup1 = ()
>>> myTup2 = tuple()
>>> type( myTup )
<class 'tuple'>
>>>
>>> myTup2 = ( 1, 2, 3, 4, 5 )
>>> print( myTup2 )
(1, 2, 3, 4, 5)
>>> type( myTup2 )
<class 'tuple'>
>>>
List ( 列表 )
构造一个列表:
# 空列表
>>> myList1 = []
>>> myList2 = list()
>>> type( myList1 )
<class 'list'>
>>> type( myList2 )
<class 'list'>
---------------------------------------------------------------------------------------
# 非空列表
>>> myList3 = [ "One", "Two", "Three" ]
>>> myList3.append( "Four" )
列表的遍历
#方法1
for i in list:
print( "序号:%s 值:%s" % ( list.index(i)+1, i ))
#方法2
for i in range(len(list)):
print( "序号:%s 值:%s" % ( i+1,list[i] )
#方法3
for i,val in enumerate(list):
print( "序号:%s 值:%s" % (i+1,val) )
函数:
序号 | 函数 |
---|---|
1 | len(list) 列表元素个数 |
2 | max(list) 返回列表元素最大值 |
3 | min(list) 返回列表元素最小值 |
4 | list(seq) 将元组转换为列表 |
方法:
序号 | 方法 |
---|---|
1 | list.append(obj) 在列表末尾添加新的对象 |
2 | list.count(obj) 统计某个元素在列表中出现的次数 |
3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
5 | list.insert(index, obj) 将对象插入列表 |
6 | list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 |
7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
8 | list.reverse() 反向列表中元素 |
9 | list.sort( key=None, reverse=False) 对原列表进行排序 |
10 | list.clear() 清空列表 |
11 | list.copy() 复制列表 |
Set ( 集合 )
构造一个集合:
# 空集合 ( 注意只能用 set()函数构造空集合, 不能用{}, {}是构造空字典的
>>> mySet1 = set()
>>> type(mySet1)
<class 'set'>
# 非空集合
>>> mySet2 = { "Student", "Teacher", "Boss", "Employee" }
>>> type( mySet2 )
<class 'set'>
集合运算
>>> a = { 'a', 'b', 'c' }
>>> b = { 'a' }
>>> print( a-b ) # 差集
{'b', 'c'}
>>> print( a|b ) # 并集
{'a', 'b', 'c'}
>>> print( a&b ) # 交集
{'a'}
>>> print( a^b ) # 两个集合不同时存在的元素
{'b', 'c'}
>>> if 'a' in a:
... print( "Yes" )
... else:
... print( "No" )
...
Yes
集合内置方法完整列表
方法 | 描述 |
---|---|
add() | 为集合添加元 |
update() | 给集合添加元素 |
pop() | 随机移除元素 |
remove() | 移除指定元素 |
discard() | 删除集合中指定的元素 |
clear() | 移除集合中的所有元素 |
difference_update() | 移除集合中的元素,该元素在指定的集合也存在。 |
symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 |
copy() | 拷贝一个集合 |
difference() | 返回多个集合的差集 |
union() | 返回两个集合的并集 |
intersection() | 返回集合的交集 |
intersection_update() | 返回集合的交集。 |
symmetric_difference() | 返回两个集合中不重复的元素集合。 |
isdisjoint() | 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 |
issubset() | 判断指定集合是否为该方法参数集合的子集。 |
issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
Dictionary ( 字典 )
构造一个字典
# 构造一个空的字典
>>> myDict1 = {}
>>> myDict2 = dict()
>>> type( myDict1 )
<class 'dict'>
>>> type( myDict2 )
<class 'dict'>
---------------------------------------------------------------------------------------
# 构造一个非空字典
>>> myDict3 = { "ZhangSan":1, "LiSi":2, "WangWu":3 }
>>> myDict3["LiLiu"] = 4
>>> myDict3["ZhaoQi"] = 4
>>> print( myDict3 )
{'ZhangSan': 1, 'LiSi': 2, 'WangWu': 3, 'LiLiu': 4, "ZhaoQi":4 }
# 注意这种构造方法只能是 字符串 作为 键
>>> c = dict( name='Allen', age=14, gender='male' )
>>> c
{'gender': 'male', 'name': 'Allen', 'age': 14}
字典的遍历
1》遍历字典的键key
for key in d:
print(str(key)+':'+str(d[key]))
for key in d.keys():
print(key)
2》遍历字典的值value
for value in d.values():
print (value)
3》遍历字典的项
for item in d.items():
print(item)
for key,value in d.items():
print(key,value)
for (key,value) in d.items():
print(key,value)
字典相关函数
>>> print( myDict3.keys() )
dict_keys(['ZhangSan', 'LiSi', 'WangWu', 'LiLiu', 'ZhaoQi'])
>>> print( myDict3.values() )
dict_values([1, 2, 3, 4, 4])
序号 | 函数及描述 | 实例 |
---|---|---|
1 | len(dict) 计算字典元素个数,即键的总数。 |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(dict) 3 |
2 | str(dict) 输出字典,以可打印的字符串表示。 |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}" |
3 | type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型。 |
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(dict) <class 'dict'> |
序号 | 函数及描述 |
---|---|
1 | radiansdict.clear() 删除字典内所有元素 |
2 | radiansdict.copy() 返回一个字典的浅复制 |
3 | radiansdict.fromkeys() 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值 |
4 | radiansdict.get(key, default=None) 返回指定键的值,如果值不在字典中返回default值 |
5 | key in dict 如果键在字典dict里返回true,否则返回false |
6 | radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组 |
7 | radiansdict.keys() 返回一个迭代器,可以使用 list() 来转换为列表 |
8 | radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default |
9 | radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里 |
10 | radiansdict.values() 返回一个迭代器,可以使用 list() 来转换为列表 |
11 | pop(key[,default]) 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。 |
12 | popitem() 随机返回并删除字典中的最后一对键和值。 |
转换函数
这些函数返回一个新的对象,表示转换的值。
函数 | 描述 |
---|---|
将x转换为一个整数 |
|
将x转换到一个浮点数 |
|
创建一个复数 |
|
将对象 x 转换为字符串 |
|
将对象 x 转换为表达式字符串 |
|
用来计算在字符串中的有效Python表达式,并返回一个对象 |
|
将序列 s 转换为一个元组 |
|
将序列 s 转换为一个列表 |
|
转换为可变集合 |
|
创建一个字典。d 必须是一个 (key, value)元组序列。 |
|
转换为不可变集合 |
|
将一个整数转换为一个字符 |
|
将一个字符转换为它的整数值 |
|
将一个整数转换为一个十六进制字符串 |
|
将一个整数转换为一个八进制字符串 |
|
将一个整数转换为一个二进制字符串 |
迭代器 与 生成器
… 不是很明白 … 待更新 …
运算符
>>>5 + 4
9
>>> 4.3 - 2
2.3
>>> 3 * 7
21
>>> 2 / 4 # 除法,得到一个浮点数
0.5
>>> 2 // 4 # 除法,得到一个整数
0
>>> 17 % 3
2
>>> 2 ** 5 # 乘方
32
多行语句 用 \ 连接
# 多行连接符
mutiply_string = \
""" this ismutiply line string.
this is the second passage.
this is the three passage.
end."""
print( mutiply_string )
>>> # 多行连接符
... mutiply_string = \
... """ this ismutiply line string.
... this is the second passage.
... this is the three passage.
... end."""
>>> print( mutiply_string )
this ismutiply line string.
this is the second passage.
this is the three passage.
end.
多个变量同时赋值
>>> _int, _float, _complex, _bool = 1, 2.2, 3+4j, True
>>> print( _int, _float, _complex, _bool, sep='\t' )
1 2.2 (3+4j) True
>>> print(type( _int),type(_float), type(_complex), type(_bool), sep='\t' )
<class 'int'> <class 'float'> <class 'complex'> <class 'bool'>
一行显示多条语句用分号 ;
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
import 与 from…import
- 在 python 用 import 或者 from…import 来导入相应的模块。
-
将整个模块(somemodule)导入,格式为: import somemodule
-
从某个模块中导入某个函数,格式为: from somemodule import somefunction
-
从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc
-
将某个模块中的全部函数导入,格式为: from somemodule import *
- from…import *语句与import区别在于:
-
import 导入模块,每次使用模块中的函数都要是定是哪个模块。
-
from…import * 导入模块,每次使用模块中的函数,直接使用函数就可以了;注因为已经知道该函数是那个模块中的了。
也就是说 from 某模块 import 某些函数; 这样相当于将这个模块的默写函数全部导入到现在这个模块里了, 直接写函数名掉用就行; 一般不建议这样, 会使程序的可读性变差
其他记录
strip() 和 split() 函数
strip()的意思是删除;
split()的意思是分割。
strip():
1.无参数时,strip()则把空格,tap等空字符删除。(strip())
2.有参数时,则把字符串中参数对应的字符串删除。(strip(‘a’))
split():
1.无参数时,默认按所有的空字符。(split())
2.有一个参数时,则按照参数对应的字符分割。(split(‘a’))
3.有两个参数时,则按照参数对应的字符分割数次。(aplit(‘a’, 1))
Oj 中的多组输入 Python 输入
# encoding: utf-8
'''''Python的输入是野生字符串,所以要自己转类型
strip去掉左右两端的空白符,返回str
slipt把字符串按空白符拆开,返回[str]
map把list里面的值映射到指定类型,返回[type]
EOF用抓异常
print后面加逗号就不会换行,否则反之,当然3.x君自行传参
题目细节没看太细,可能有的地方不对,不要在意这些细节啦
これは以上です'''
# 有多组输入数据,但没有具体的告诉你有多少组,只是让你对应每组输入,应该怎样输出。
while True:
try:
a, b = map(int, raw_input().strip().split())
print a + b,
except EOFError:
break
# 输入一个整数,告诉我们接下来有多少组数据,然后在输入每组数据的具体值。
tcase = int(raw_input().strip())
for case in range(tcase):
a, b = map(int, raw_input().strip().split())
print a + b,
# 有多组输入数据,没有具体的告诉你有多少组,但是题目却告诉你遇见什么结束
while True:
a, b = map(int, raw_input().strip().split())
if a == 0 and b == 0:
break
print a + b,
# 输入有多组,并却题目告诉你每组输入遇见什么结束,与第三种不同之处在于,每组输入都有相应的细化。
tcase = int(raw_input().strip())
for case in range(tcase):
a, b = map(int, raw_input().strip().split())
if a == 0 and b == 0:
break
print a + b,
# 这次的输入实现输入一个整数,告诉我们有多少行,在输入每一行。对于每一行的输入,有划分为第一个数和其他的数,第一个数代表那一组数据一共有多少输入。
tcase = int(raw_input().strip())
for case in range(tcase):
data = map(int, raw_input().strip().split())
n, array = data[0], data[1:]
sum = 0
for i in range(n):
sum += array[i]
print sum,
# 有多种输入数据,对于每组输入数据的第一个数代表该组数据接下来要输入数据量
while True:
try:
data = map(int, raw_input().strip().split())
n, array = data[0], data[1:]
sum = 0
for i in range(n):
sum += array[i]
print sum,
except EOFError:
raise
# 这道题的输出只是简单的在每组输出后边多加一个换行而已!
while True:
try:
a, b = map(int, raw_input().strip().split())
print a + b
except EOFError:
break
# 这种类型的输出注意的就是换行,这类题目说在输出样例中,每组样例之间有什么什么,所以我们在对应输出的同时要判断一下是否是最后一组输出,如果不是,就 将题目所说的东西输出(一般是换行或空格),如果是,就直接结束。
while True:
data = raw_input().strip()
if data.isspace():
break
else:
data = map(int, data)
n, array = data[0], data[1:]
sum = 0
for i in range(n):
sum += array[i]
print sum,
多组输入转载自: http://blog.csdn.net/luovilonia/article/details/40860323
# Enter your code here. Read input from STDIN. Print output to STDOUT
from sys import stdin
team=[]
while True:
line = stdin.readline().strip()
if line=='':
break
item = line.split(' ')
item = [int(i) for i in item]
team.append(item)
print team