php 字符串 1_2_3 和 2_4_5 汉英有相同的,2021-03-22

Python基础语法：

(1)打印出hello world

# -*- coding: utf-8 -*-

print "hello world"

print "你好 世界"

(2)注释

1、(单行注释)以 # 开头，后面的文字直到行尾都算注释

2、(多行注释)多行注释是用三引号'''  '''包含的(单引号和双引号均可)

3、(中文注释)要注释中文必须程序开头先写上# -*- coding: utf-8 -*-，不然会报错

(3)数据类型

1、变量不需要声明，可以直接输入，大小写敏感

2、这里的var = xxxx不叫变量赋值，而叫变量绑定，一个符号可以绑定任意类型的值。

3、内置函数type(), 用以查询变量的类型

var = 1

print var  #1

print type(var)  #整数类型 #

var = 1.1

print var  #  1.1

print type(var)  #浮点数类型  #

var = 'hello'

print var  # hello

print type(var)  #字符串  #

var = (1==1)

print var  # True

print type(var)  #布尔型  #

var = None

print var  # None

print type(var)  #空值  #

var = 1+1j  或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

print var  # (1+1j)

print type(var)  #复数类型    #

4、字符串以''或" "括起来的任意文本

5、布尔型(True, False，可以用and, or, not运算，而不是C语言的&&和||)

6、多变量赋值

a = b = c = 1

a, b, c = 1, 2, "john"    #等号两边都是元组，建议加上括号，增加可读性

x,y = y,x    #两值交换，不需要temp,更加简洁

7、赋值语句不可以返回值，对象是通过引用传递的

y = (x = x + 1)  #这是非法的

(4)运算

1、加、减、乘、除、求余、乘方

2、乘方  ** 右结合

2**3=8

2**2**3=256

(2**2)**3=64

3、整数运算结果仍然是整数，浮点数运算结果仍然是浮点数。

但是整数和浮点数混合运算的结果就变成浮点数了。

4、字符串与整数相乘

print 'abc' * 3  结果 abcabcabc

5、因为Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True

True and 'a=T' 计算结果是 'a=T'

继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'

要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。

①在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

②在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

6、不支持自加(i++)和自减(i--)

7、地板除(//)除法不管操作数何种数值类型，总是舍去小数部分，返回数字序列中比真正的商小的最接近的数字。

print 5//3  #1

print 1.0//2.0  #0.0

print -1/2  #-1

(5)输入

x = input()  #1+2

print type(x)  #

y = raw_input()  #1+2

print type(y)    #

1、由此可见, input() 在对待纯数字输入返回所输入的数字的类型(int，float)

而raw_input() 将所有输入作为字符串看待，返回字符串类型。

为了避免类型发生错误，一般情况下使用 raw_input() 来与用户交互。

(6)输出

1、Python2 里面print可以直接接字符串或者运算。

2、Python3 里面print变成了一个函数，上面的写法不支持了，必须用一个括号括起来，否则会报告语法错误。

3、>>>是Python解释器的提示符，不是代码的一部分。

4、print语句也可以跟上多个字符串，用逗号“,”隔开，遇到逗号“,”会输出一个空格：

print '1+2=',1+2  #1+2= 3

5、多行输出使用三个引号和使用换行符n一致

print '''哈

哈

哈'''

print "哈n哈n哈"

#  输出结果

# 哈

# 哈

# 哈

# 哈

# 哈

# 哈

6、转义

print r'C:log.txt'

print 'C:\log.txt'

# C:log.txt

# C:log.txt

7、print 语句与字符串格式运算符( % )结合使用，可实现字符串替换功能

print "%s is number %d!" % ("Python", 1)

%s表示由一个字符串来替换，%d表示由一个整数来替换，%f表示由一个浮点数来替换。

Python 非常灵活，即使将数字传递给 %s，也不会像其他要求严格的语言一样引发严重后果。

(7)序列

1、序列有两种： list (可变列表) 和tuple(不可变元组)

2、定义:序列是一组有顺序的元素的集合,可以包含一个或多个元素，也可以没有任何元素。

list  =  [0,1,2,3,4,5]    #列表用中括号，可改变，理解为数组

tuple =  (0,1,2,3,4,5)    #元祖用小括号，不可改变

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型

2、序列的通用操作

seq = "0123456789"

print seq[0] #序列元素的下标从0开始。注意不要越界

print seq[-1] #倒序索引，-1代表倒数第一。

print seq[1:5] #支持切片操作，seq[start:end]，start包含在结果中，end不包含在结果中。

print range(1,101)[0:10]#从第1个数元素开始取，到第11元素结束

print seq[7:] #seq[start:end]中的end可以省略。

print seq[-3:] #分片也支持负数。

print seq[:3] #seq[start:end]中的start也可以省略。

print seq[:] #全部省略会复制整个序列。

print seq[::2] #支持步长。

print seq[::-1] #逆序输出。

print seq[9:1:-1] #支持负步长。

print range(1,101)[2::3]#从第三元素开始取，每隔2个取一个元素，即3的倍数

print range(1,101)[4:50:5]#从第五个取，每隔4个取一个，50以内5的倍数

print [1, 2, 3] + [4, 5, 6] # 序列支持相加，这解释了为啥字符串可以相加。

print [1, 2, 3] * 3 #序列支持相乘，这解释了为啥字符串可以相称。

print [None] * 10 #生成一个空序列。

print 1 in [1, 2, 3] #成员判断。

print range(1,101)[4::5][-10:] #切片可以嵌套，最后10个5的倍数，先获得5的倍数再取后10个

记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

3、可变的列表(list)

list = [0,1,2,3,4,5]

list.append(7)  #append()总是把新元素添加到list的尾部

print list  # [0, 1, 2, 3, 4, 5, 7]

list.insert(0,-1)  #insert()接受两个参数，第一个是索引，第二个是元素

print list  # [-1, 0, 1, 2, 3, 4, 5, 7]

list.insert(-1,6) #insert(-1)是最后一个元素之前，即倒数第二个元素，因为insert()前插

print list  # [-1, 0, 1, 2, 3, 4, 5, 6, 7]

list.pop()  #pop()方法总是删掉最后一个元素

print list  # [-1, 0, 1, 2, 3, 4, 5, 6]

list.pop(0) #参数为索引

print list  # [0, 1, 2, 3, 4, 5, 6]

list[6]=7 #对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素

print list  # [0, 1, 2, 3, 4, 5, 7]

list[0],list[-1]=list[-1],list[0] #第一与最后位置调换

print list  # [7, 1, 2, 3, 4, 5, 0]

在使用可变对象的方法如 sort(),extend()和 reverse()的时候要注意,这些操作会在列表

中原地执行操作,也就是说现有的列表内容会被改变,但是没有返回值!

4、不可变的元组(tuple)

字符串是一种特殊的元组

没有 append()方法，也没有insert()和pop()方法，也不能赋值

Tuple 比 list 操作速度快.如果您定义了一个值的常量集,并且唯一要用它做的是不断地遍历它,请使用 tuple 代替 list.如月份，星期。

print (1,) #一个元素的元祖。

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义。

可变的元组：tuple的元素指向list，而list内的值可变

5、序列解包

x, y, z = 1, 2, 3

print x, y, z

(x, y, z) = (1, 2, 3)

print x, y, z

(x, y, z) = [1, 2, 3]

print x, y, z

(8)相等比较

#== 和 is的差别，==比较的是值，is比较的是引用。

x = [1, 2, 3]

y = x

z = [1, 2, 3]

print(x == y) #True

print(x == z) #True

print(x is y) #True

print(x is z) #False

(9)选择

1、Python代码的缩进规则。具有相同缩进的代码被视为代码块

2、缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格

3、格式

if  条件1:

statement

elif 条件2:

statement

elif 条件3：

statement

else:

statement

If后面不需要括号，但是条件后面需要冒号

elif 即 else if

4、三元运算符

x, y = 4, 3

if x < y:

result = x

else:

result = y

print result

#等价于

result = x if x < y else y

print result

(10)循环

1、for循环依次把list或tuple的每个元素迭代出来

格式

for 元素 in 序列:

statement

name 这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体(就是缩进的代码块)

L = ['Adam', 'Lisa', 'Bart']

for name in L:

print name

这样一来，遍历一个list或tuple就非常容易了。

2、while循环，不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束。

while 条件:

statement

3、中断循环 break和continue

4、range()的用法

range(1,5) #代表从1到5(不包含5)  [1, 2, 3, 4]

range(1,5,2) #代表从1到5，间隔2(不包含5)  [1, 3]

range(5) #代表从0到5(不包含5)  [0, 1, 2, 3, 4]

5、Python中，迭代永远是取出元素本身，而非元素的索引。

对于有序集合，元素确实是有索引的。使用enumerate() 函数拿到索引

L = ['Adam', 'Lisa', 'Bart', 'Paul']

for index, name in enumerate(L):

print index, '-', name

#结果

# 0 - Adam

# 1 - Lisa

# 2 - Bart

# 3 - Paul

使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name。但是，这不是 enumerate() 的特殊语法。实际上，enumerate() 函数把：

['Adam', 'Lisa', 'Bart', 'Paul']

变成了类似：

[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]

因此，迭代的每一个元素实际上是一个tuple：

6、好用的zip()方法

for x, y in zip(range(1, 10), range(1, 10)):

print(x, y)

# 结果

# (1, 1)

# (2, 2)

# (3, 3)

# (4, 4)

# (5, 5)

# (6, 6)

# (7, 7)

# (8, 8)

# (9, 9)

7、列表生成式，非常简洁

要生成[1x1, 2x2, 3x3, ..., 10x10]

print [x * x for x in range(1, 11)]

#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表生成式的 for 循环后面还可以加上 if 判断。例如：

print  [x * x for x in range(1, 11) if x % 2 == 0]

# [4, 16, 36, 64, 100]

8、迭代器

它为类序列对象提供了一个类序列的接口。

迭代非序列集合(例如映射和文件)时, 可以创建更简洁可读的代码。

myTuple = (123, 'xyz', 45.67)

i = iter(myTuple)

print i.next()  #123

print i.next()  #xyz

print i.next()  #45.67

i.next()        #报错

(11)字典(dict)

1、字典的元素没有顺序。你不能通过下标引用元素。字典是通过键来引用，用大括号

查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

dict的缺点是占用内存大，还会浪费很多内容

dict是按 key 查找，所以，在一个dict中，key不能重复

作为 key 的元素必须不可变

2、已知两个列表，一个是名字，一个是成绩，要根据名字找到对应的成绩用两个list不方便，如果把名字和分数关联起来，组成类似的查找表，即 Python中的dict

用 dict 表示“名字”-“成绩”的查找表如下：

dic = {'tom':11, 'sam':57,'lily':100}

print type(dic)  #

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

print d  #{'Lisa': 85, 'Adam': 95, 'Bart': 59}

3、我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。

4、花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

5、由于dict也是集合，len()函数可以计算任意集合的大小：

print len(d)  #运算结果为3

一个 key-value 算一个，因此，dict大小为3。

6、可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key：

print d['Adam']  #95

注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。

要避免 KeyError 发生，有两个办法：

一是先判断一下 key 是否存在，用 in 操作符：

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：

print d.get('Bart')  #59

print d.get('Paul')  #None

7、在字典中增添一个新元素的方法：

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

print d  #{'Lisa': 85, 'Adam': 95, 'Bart': 59}

d['lilei'] = 99

print d  #{'lilei': 99, 'Lisa': 85, 'Adam': 95, 'Bart': 59}

8、循环调用

for key in d:  #或for key in d.keys()

print d[key]

# 结果

# 99

# 85

# 95

# 59

9、字典的常用方法

print d.keys()          # 返回d所有的键

print d.values()        # 返回d所有的值

print d.items()        # 返回d所有的元素(键值对)

d.clear()            # 清空d，dict变为{}

del d[‘xxx’]                  # 删除 d 的‘xxx’元素

for key, value in d.items():

print key, ':', value

10、cmp()比较

(1)先比较字典长度

(2)再比较字典的键

(3)最后比较字典的值

(4)都一样就相等

(12)集合(set)(不常用)

1、dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

2、set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

3、创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：

s = set(['A', 'B', 'C'])

print s  #set(['A', 'C', 'B'])

4、添加、删除：

s.add('D')

print s  #set(['A', 'C', 'B', 'D'])

s.add('D') #已存在不会报错

s.remove('D')

print s  #set(['A', 'C', 'B'])

s.remove('D')  #报错，需要先判断