python基础教程1

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)

运行结果：

1. c 的值为： 31
2. c 的值为： 11
3. c 的值为： 210
4. c 的值为： 2.1
5. c 的值为： 1
6. c 的值为： 8
7. 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")

运行结果：

1. a 不等于 b
2. a 不等于 b
3. a 大于等于 b
4. a 大于 b
5. a 小于等于 b
6. 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)