Python基础（一）

1、数据类型和编码：

整数：

浮点数：

字符串：
字符串是以单引号’ '或双引号" "括起来的任意文本。

'I\'m \"OK\"!'
结果：
I'm "OK"!

转义字符：
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\。

r’‘表示’'内部的字符串默认不转义。
Python允许用’’’…’’'的格式表示多行内容。

print('''line1
line2
line3''')
结果：
line1
line2
line3

布尔值：（True False）
布尔值可以用and、or和not运算。

空值：（None）

变量：
变量名必须是大小写英文、数字和_的组合，且不能用数字开头。

常量：
在Python中，通常用全部大写的变量名表示常量。

2、字符串和编码

Python的字符串：
对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符。

print(ord('a'))
print(ord("中"))

print(chr(66))
print(chr(25991))
结果：
97
20013
B
文

如果知道字符的整数编码，还可以用十六进制这么写str：

print('\u4e2d\u6587')
结果：
中文

要计算str包含多少个字符，可以用len()函数：

print(len('张言我爱你'))
print(len('zhang yan wo ai ni'))
结果：
5
18

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数。

print(len('张言我爱你'.encode('utf-8')))
print(len(b'zhangyanwoaini'))
结果:
15
14

1个中文字符经过UTF-8编码后通常会占用3个字节，而1个英文字符只占用1个字节。

格式化
在Python中，采用的格式化方式和C语言是一致的，用%实现。

print('Hi, %s, you have $%d.' % ('Michael', 1000000))
结果：
Hi, Michael, you have $1000000.

常见的占位符有：

符号	功能
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

print('%d,,,%d' % (3333,4444))
print('%03d,,,%03d'% (88,9))
结果：
3333,,,4444
088,,,009

%s永远起作用，它会把任何数据类型转换为字符串。
用%%来表示一个%。

3、列表list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
内置确定序列的长度以及确定最大和最小的元素的方法。
列表可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型。
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
创建：

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

用len()函数可以获得list元素的个数：

print(len(list1))
print(len(list2))
print(len(list3))
结果：
4
5
4

用索引来访问list中每一个位置的元素，索引是从0开始的，最后一个元素的索引是len(列表名) - 1。

print(list1[0])
print(list1[-1])
print((list2[-3]))
结果：
physics
2000
3

list是一个可变的有序表，所以，可以往list中使用append(元素)追加元素到末尾。

list1.append("boy")
list2.append(6)
list3.append("e")
结果：
['physics', 'chemistry', 1997, 2000, 'boy']
[1, 2, 3, 4, 5, 6]
['a', 'b', 'c', 'd', 'e']

使用insert(位置，元素)把元素添加到指定位置。

list1.insert(1, 'math')
list2.insert(0, 0)
list3.insert(5, 'f')
结果：
['physics', 'math', 'chemistry', 1997, 2000, 'boy']
[0, 1, 2, 3, 4, 5, 6]
['a', 'b', 'c', 'd', 'e', 'f']

使用pop(元素所在位置)删除元素，pop()即为删除列表末尾元素。

list1.pop(1)
list2.pop(0)
list3.pop()
结果：
['physics', 'chemistry', 1997, 2000, 'boy']
[1, 2, 3, 4, 5, 6]
['a', 'b', 'c', 'd', 'e']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置。

list1[1] = "math"
list2[5] = 7
list3[0] = "A"
结果：
['physics', 'math', 1997, 2000, 'boy']
[1, 2, 3, 4, 5, 7]
['A', 'b', 'c', 'd', 'e']

list里面的元素的数据类型也可以不同。

L = ['Apple', 123, True]

list元素也可以是另一个list。

s = ['python', 'java', ['asp', 'php'], 'scheme']
len(s)
4
#要注意s只有4个元素，其中s[2]又是一个list
#要拿到'php'可以写成s[2][1]

元组tuple

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
结果：
('Google', 'Runoob', 1997, 2000)
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd')

如果要定义一个空的tuple，可以写成：

tup = ()

只有1个元素的tuple定义时必须加一个逗号。

t = (1,)
print(tup)
结果：
(1,)

tup = 1,
print(tup)
结果：
(1,)

tup = (1)
print(tup+1)
结果：
2

tup = (1,)
print(tup+1)
结果：
error!
懂？

一个**“可变的”**tuple

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
#t[2]是一个list！

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

4、条件判断

age = 20
if age >= 18:
    print('your age is', age)
    print('adult')

age = 3
if age >= 18:
    print('your age is', age)
    print('adult')
else:
    print('your age is', age)
    print('teenager')

age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else。

if x:
    print('True')

只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

input

birth = input('birth: ')
if birth < 2000:
    print('00前')
else:
    print('00后')
输入1984，结果报错
input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。

s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

5、循环

for…in循环

结构：
for <variable> in <sequence>:
    <statements>
else:
    <statements>


sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)
结果
55

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")
结果：
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

range()，生成数列

print(list(range(10)))
结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

sum = 0
for x in range(101):
    sum = sum + x
print(sum)
结果：
5050

可以使用range指定区间的值
for i in range(5,9) :
    print(i)
结果：
5
6
7
8

可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长')
for i in range(0, 10, 3) :
    print(i)
结果：
0
3
6
9

步长可以为负数：
for i in range(-10, -100, -30) :
    print(i)
结果：
-10
-40
-70

while循环

sum = 0
n = 100
while n > 0:
    sum = sum + n
    n = n - 1
print(sum)
结果：
5050

break 和 continue 语句及循环中的 else 子句 。

while 中使用 break：
n = 5
while  n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
结果：
4
3
..........
while 中使用 continue：
n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
结果：
4
3
1
0

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。

找质数：
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')
结果：
2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

pass语句：Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。

for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)
 
print ("Good bye!")

结果：
当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

6、使用dict和set

字典dict：
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中。

字典的创建于使用：

d = {key1 : value1, key2 : value2 }
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

dict = {'a': 1, 'b': 2, 'b': '3'}
dict['b']
'3'
dict
{'a': 1, 'b': '3'}

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：
dict = {"a":100}
if "a" in dict:
    print(dict["a"])
结果：
100

二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：
dict = {"a":100}
if dict.get("a"):
    print(dict['a'])
结果：
100

修改字典：
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8               # 更新 Age
dict['School'] = "菜鸟教程"  # 添加信息
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
结果：
dict['Age']:  8
dict['School']:  菜鸟教程

删除字典元素：

del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

字典键的特性：
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1、不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
2、键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而增加；
需要占用大量的内存，内存浪费多。

而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

字典内置函数&方法：

函数	说明
len(dict)	计算字典元素个数，即键的总数
str(dict)	输出字典，可以打印的字符串表示。
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

集合：set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作。

a = set([1,2,3,4,5,6,7])
print(a)
{1, 2, 3, 4, 5, 6, 7}
# 要有中括号！

b = {1,2,6,9,4}
print(b)
{1, 2, 4, 6, 9}
# 注意输出和b的定义形式

a = set('abr1acadabra9')
b = set('alac8azam2')
print(a)
print(b)
#结果：
{'9', 'b', 'a', 'd', '1', 'c', 'r'}
{'a', 'l', 'm', 'c', '2', 'z', '8'}

print(a - b)
{'d', '1', '9', 'b', 'r'}
# 集合a中包含而集合b中不包含的元素

print(a | b)
{'9', 'l', '8', 'm', 'c', 'b', 'a', '1', 'r', 'd', '2', 'z'}
# 集合a或b中包含的所有元素

print(a & b)
{'a', 'c'}
 # 集合a和b中都包含了的元素
 
print(a ^ b)
{'8', 'm', 'b', '1', '9', 'l', 'r', 'd', '2', 'z'}
# 不同时包含于a和b的所有元素

集合的基本操作：
添加元素：

s.add( x )
# 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
a = set('abr1acadabra9')
a.add('KKKK')
print(a)
结果：
{'a', 'KKKK', '9', '1', 'c', 'b', 'r', 'd'}

#还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x )
a = set('abr1acadabra9')
a.update("KKK")
print(a)
结果：
{'1', '9', 'r', 'c', 'd', 'a', 'K', 'b'}

a = set('abr1acadabra9')
a.update("ABC23")
print(a)
结果：
{'2', '3', 'd', 'B', '1', 'A', 'b', '9', 'C', 'r', 'c', 'a'}
#注意和a.add()的区别。

a = set('abc9')
a.update({2,3,"A"})
a.update("B")
a.update(["C",6])
#几种不同的表达方式
print(a)
结果：
{2, 3, 6, 'C', 'A', 'a', 'b', 'c', '9', 'B'}

移出元素：

s.remove( x )
# 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
a = set('abcd789')
a.remove("a")
print(a)
结果:
{'b', '8', '9', '7', 'c', 'd'}

#此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。
s.discard( x )

#我们也可以设置随机删除集合中的一个元素，语法格式如下：
s.pop() 

a = set('abcd789')
x = a.pop()
print(a)
print(x)
结果：
{'9', 'c', 'b', '7', '8', 'd'}
a
#多次执行测试结果都不一样。
#set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

#通过a.remove(元素)删除集合中的指定元素。
a.remove(x)

a = set('abcd789')
a.remove("b")
print(a)
结果：
{'9', '7', 'a', 'c', 'd', '8'}

清空集合：

s.clear()

判断元素是否在集合中存在

x in s

a = set('abcd789')
print("a" in a)
结果：
True

集合内置方法完整列表。

再议不可变量。

str是不变对象，而list是可变对象。

对于可变对象，比如list，对list进行操作，list内部的内容是会变化的。

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作。
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'
虽然字符串有个replace()方法，也确实变出了'Abc'，但变量a最后仍是'abc'。

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
'Abc'
>>> a
'abc'

要始终牢记的是，a是变量，而’abc’才是字符串对象！有些时候，我们经常说，对象a的内容是’abc’，但其实是指，a本身是一个变量，它指向的对象的内容才是’abc’。
当我们调用a.replace(‘a’, ‘A’)时，实际上调用方法replace是作用在字符串对象’abc’上的，而这个方法虽然名字叫replace，但却没有改变字符串’abc’的内容。相反，replace方法创建了一个新字符串’Abc’并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串’abc’，但变量b却指向新字符串’Abc’了。