1.输入输出和运算符
1.1输入输出
a_input = input('please input a number:')
score = int(input('Please input your score: \n'))
a_input 返回值类型为str
score 将返回值类型转换为int
print("hello, world")
## 占位符
## %d 整数
## %f 浮点数
## %s 字符串
## %x 十六进制整数
print('Age: %s. Gender: %s' % (25, True))
运行结果:
hello, world
Age: 25. Gender: True
1.2.运算符
1.2.1算术运算符
假设变量a为10,变量b为21:
#coding=utf-8
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值为:", c)
c = a - b
print ("2 - c 的值为:", c)
c = a * b
print ("3 - c 的值为:", c)
c = a / b
print ("4 - c 的值为:", c)
c = a % b
print ("5 - c 的值为:", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print ("6 - c 的值为:", c)
a = 11
b = 5
c = a//b
print ("7 - c 的值为:", c)
运行结果:
- c 的值为: 31
- c 的值为: 11
- c 的值为: 210
- c 的值为: 2.1
- c 的值为: 1
- c 的值为: 8
- c 的值为: 2
1.2.2比较运算符
假设变量a为10,变量b为20
#!/usr/bin/python3
#coding=utf-8
a = 21
b = 10
c = 0
if ( a == b ):
print ("1. a 等于 b")
else:
print ("1. a 不等于 b")
if ( a != b ):
print ("2. a 不等于 b")
else:
print ("2. a 等于 b")
if ( a < b ):
print ("3. a 小于 b")
else:
print ("3. a 大于等于 b")
if ( a > b ):
print ("4. a 大于 b")
else:
print ("4. a 小于等于 b")
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
print ("5. a 小于等于 b")
else:
print ("5. a 大于 b")
if ( b >= a ):
print ("6. b 大于等于 b")
else:
print ("6. b 小于 b")
运行结果:
- a 不等于 b
- a 不等于 b
- a 大于等于 b
- a 大于 b
- a 小于等于 b
- b 大于等于 b
1.2.3赋值运算符
假设变量a为为10,变量b为20
#!/usr/bin/python3
#coding=utf-8
a = 21
b = 10
c = 2
c = a + b
print ("1.c 的值为:", c)
c = 2
a = 21
c += a
print ("2.c 的值为:", c)
c = 0
a = 21
c *= a
print ("3.c 的值为:", c)
c = 0
a = 21
c /= a
print ("4.c 的值为:", c)
c = 2
a = 21
c %= a
print ("5.c 的值为:", c)
c = 2
a = 21
c **= a
print ("6.c 的值为:", c)
c = 2
a = 21
c //= a
print ("7.c 的值为:", c)
运行结果
1.c 的值为: 31
2.c 的值为: 23
3.c 的值为: 0
4.c 的值为: 0.0
5.c 的值为: 2
6.c 的值为: 2097152
7.c 的值为: 0
1.2.4逻辑运算符
假设变量 a 为 10, b为 20:
1.2.5成员运算符
#!/usr/bin/python3
#coding=utf-8
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print ("1 - 变量 a 在给定的列表中 list 中")
else:
print ("1 - 变量 a 不在给定的列表中 list 中")
if ( b not in list ):
print ("2 - 变量 b 不在给定的列表中 list 中")
else:
print ("2 - 变量 b 在给定的列表中 list 中")
# 修改变量 a 的值
a = 2
if ( a in list ):
print ("3 - 变量 a 在给定的列表中 list 中")
else:
print ("3 - 变量 a 不在给定的列表中 list 中")
运行结果:
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
1.2.6 身份运算符
身份运算符用于比较两个对象的存储单元
#!/usr/bin/python3
#coding=utf-8
a = 20
b = 20
if ( a is b ):
print ("1 - a 和 b 有相同的标识")
else:
print ("1 - a 和 b 没有相同的标识")
if ( id(a) == id(b) ):
print ("2 - a 和 b 有相同的标识")
else:
print ("2 - a 和 b 没有相同的标识")
# 修改变量 b 的值
b = 30
if ( a is b ):
print ("3 - a 和 b 有相同的标识")
else:
print ("3 - a 和 b 没有相同的标识")
if ( a is not b ):
print ("4 - a 和 b 没有相同的标识")
else:
print ("4 - a 和 b 有相同的标识")
运行结果:
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
1.2.7运算符优先级
#!/usr/bin/python3
#coding=utf-8
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为:", e)
e = ((a + b) * c) / d # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为:", e)
e = (a + b) * (c / d); # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为:", e)
e = a + (b * c) / d; # 20 + (150/5)
print ("a + (b * c) / d 运算结果为:", e)
运行结果:
(a + b) * c / d 运算结果为: 90.0
((a + b) * c) / d 运算结果为: 90.0
(a + b) * (c / d) 运算结果为: 90.0
a + (b * c) / d 运算结果为: 50.0
2.列表
Python中内置了多种序列,其中列表和元组是最常用的两种。列表和元组的主要不同在于,列表是可以修改的,而元组不可以。这意味着列表适用于需要中途添加元素的情形,而元组适用于出于某种考虑需要禁止修改序列的情形。
2.1通用的序列操作
包括索引、切片、相加、相乘和成员资格检查
索引: 序列中的所有元素都有编号——从0开始递增。你可像下面这样使用编号来访问各个元素:
>>> greeting = 'Hello'
>>> greeting[0]
'H'
切片 用于访问特定范围内的元素。为此, 可使用两个索引,并用冒号分隔: 第一个索引是包含的第一 个元素的编号,第二个索引是切片后余下的第一个元素的编号,即切片到此元素前一个。负数表示从列表末尾开始数,-1为最后一个元素。
>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6]
[4, 5, 6]
>>> numbers[0:1]
[1]
>>>numbers[-3:-1]
[8,9]
相加 可以用加法运算拼接序列
>>>[1,2,3]+[4,5,6]
[1,2,3,4,5,6]
>>>'hello, '+'world'
'hello, world'
乘法 将序列与数x相乘,表示将重复这个序列x次来创建一个新的序列:
>>>'python' * 5
'pythonpythonpythonpythonpython'
2.2列表
2.2.1列表的操作
1.函数list 创建列表 鉴于不能像修改列表那样修改字符串,因此在有些情况下使用字符串来创建列表很有帮助。 为此,可使用函数list()。
>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
注:可将任何序列(而不仅仅是字符串)作为list的参数。
2.修改列表: 给元素赋值 修改列表很容易,只需使用普通赋值语句即可,但不是使用类似于x = 2这样的 赋值语句,而是使用索引表示法给特定位置的元素赋值,如x[1] = 2。
>>> x = [1, 1, 1]
>>> x[1] = 2
>>> x
[1, 2, 1]
注:不能给不存在的元素赋值
3.删除元素: 从列表中删除元素也很容易,只需使用del语句即可。
>>> names = ['Alice', 'Beth',
'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth','Dee-Dee', 'Earl']
此时‘Cecil’彻底消失了,而列表的长度也从5变成了4。
4.给切片赋值: 切片是一项极其强大的功能,而能够给切片赋值让这项功能显得更加强大。
>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']
从上述代码可知,可同时给多个元素赋值。
通过使用切片赋值,还可将切片替换为长度与其不同的序列。
>>> name = list('Perl')
>>> name[1:] = list('ython')
>>> name
['P', 'y', 't', 'h', 'o','n']
使用切片赋值还可在不替换原有元素的情况下插入新元素。
>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]
在这里,“替换”了一个空切片,相当于插入了一个序列。可采取相反的措施来删除 切片。
>>> numbers [1, 2, 3, 4, 5]
>>> numbers[1:4] = []
>>> numbers
[1, 5]
上述代码与del numbers[1:4]等效。
2.2.2列表的方法
方法是与对象(列表、数、字符串等)联系紧密的函数。
通常,像下面这样调用方法:
object.method(arguments)
方法调用与函数调用很像,只是在方法名前加上了对象和句点。
列表包含多个可用来查看或修改其内容的方法。
1.append 方法
append用于将一个对象附加到列表末尾。
>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst [1, 2, 3, 4]
与其他几个类似的方法一样,append也就地修改列表。这意味着它不会返回修改后的新列表,而是直接修改旧列表。
2. clear 方法
clear就地清空列表的内容。
>>> lst = [1, 2, 3]
>>> lst.clear()
>>> lst []
这类似于切片赋值语句lst[:] = []。
3.copy 方法
>>> a=[1,2,3]
>>> b=a.copy()
>>> b
[1, 2, 3]
4.count 方法
count计算指定的元素在列表中出现了多少次。
>>> ['to', 'be', 'or', 'not',
'to', 'be'].count('to')
2
>>> x = [[1, 2], 1, 1, [2, 1, [1,2]]]
>>> x.count(1)
2
>>> x.count([1, 2])
1
5. extend 方法
extend让你能够同时将多个值附加到列表末尾,为此可将这些值组成的序列作为参数提供给方法extend。换而言之,你可使用一个列表来扩展另一个列表。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a [1, 2, 3, 4, 5, 6]
6.pop 方法
pop从列表中删除一个元素(未指定时默认为最后一个元素),并返回这一元素。
>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]
7.remove 方法
remove用于删除指定元素。
>>> x = ['to', 'be', 'or', 'not','to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
8.reverse
方法reverse按相反的顺序排列列表中的元素
>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]
注意到reverse修改列表,但不返回任何值(与remove和sort等方法一样)。
9.sort 方法
sort用于对列表就地排序。就地排序意味着对原来的列表进行修改,使其元素按顺序排列,而不是返回排序后的列表的副本。
>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]
2.3元组
同列表一样,元组也是一种序列,唯一区别在于元组不能修改。元组的创建只需要将一些值用逗号分隔即可自动创建。
>>>1,2,3
(1,2,3)
常见的创建方式是用括号括起
>>>(1,2,3)
(1,2,3)
可以创建空元组和只有一个值的元组,虽然只有一个值也必须在它后面加逗号。
>>>()
()
>>>(42,)
(42,)
元组的创建中逗号至关重要,下面第一个示例并未创建元组,(42)和42完全等价。
>>> 3 * (40 + 2)
126
>>> 3 * (40 + 2,)
(42, 42, 42)
函数tuple()将序列作为参数,转换成元组,若参数已经是元组,就返回它。
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1, 2, 3))
(1, 2, 3)