Paython 基础语法

====数据类型======================================

** Python 中的变量赋值不需要类型声明

** Python中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头，区分大小写

** 以下划线开头的标识符有特殊意义。如：_foo 不能直接访问，需通过类提供的接口进行访问

** 在 python 中，变量是没有类型的，如：

a=[1,2,3]

a="Runoob"

[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，

它仅仅是一个对象的引用（一个指针），可以指向 List 类型对象，也可以指向 String 类型对象

** Python3有六个标准的数据类型：

Number（数字）

String（字符串）

List（列表）

Tuple（元组）

Dictionary（字典）

Set（集合，Python3新加的）

----数字---------------

Python3支持三种不同的数字类型：

int（有符号整型）

float（浮点型）

complex（复数：由实数和虚数构成，用a + bj,或complex(a,b)来表示）

# long（长整型，注：在Python3里被去除了)

a=100

print(a)

b=1.23

print(b)

c=10+2j #复数(实数+虚数)

print(c)

----字符串----------

** 使用引号( ' )、双引号( " )、三引号( ''' 或 """ )来表示字符串

** 其中三引号可以由多行组成

a = 'word'

b = "这是一个句子"

c = '''这是一个段落,

包含了多个语句'''

print(a,b,'\n',c) # 中间用空格间隔

str = 'Hello World!'

print(str)

print(str[0]) # 输出字符串中的第一个字符

print(str[2:5]) # 输出字符串中第三个至第五个(不包含第5个)之间的字符串

print(str[2:]) # 输出从第三个字符开始的字符串

print(str * 2) # 输出字符串两次

print(str + "TEST") # 输出连接的字符串

#print(str+1) # 错误，不可以是非字符串类型(和java不一样)

** 这种方法效率低

# python中字符串是不可变的类型，使用 + 连接两个字符串时会生成一个新的字符串，生成新的字符串

# 就需要重新申请内存，当连续相加的字符串很多时(a+b+c+d+e+f+...) ，效率低下就是必然的了

print('a' + 'b' + 'c')

# 略复杂，但对多个字符进行连接时效率高，只会有一次内存的申请。

# 如果是对list的字符进行连接的时候，这种方法是首选

listStr = ['a', 'b', 'c']

s = ''.join(listStr)

print(s)

# 字符串格式化，这种方法非常常用

print('%s%s%s' % ('a', 'b', 'c'))

print( 'Hello: %s %s %s' % ('aaa', 100, 22.3) )

PS:多个变量同时赋值

a,b,c=1,2.2,"abc"

print(a,b,c)

----列表------------

List（列表）是Python中使用最频繁的数据类型

列表支持字符，数字，字符串，还可以包含列表（即嵌套）

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]

tinylist = [123, 'john']

print(list) # 输出完整列表

list[0]='aaa'

print(list[0]) # 输出列表的第一个元素

print(list[1:3]) # 输出第二个至第三个的元素，不包括第三个

print(list[2:]) # 输出从第三个开始至列表末尾的所有元素

print(tinylist * 2) # 列表元素重复两次

print(list + tinylist) # 将两个列表合并

----元组--------

** 元组是另一种数据类型，类似于List（列表）。

** 元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )

tinytuple = (123, 'john')

print(tuple) # 输出完整元组

# tuple[0]='aaa' # 错误

print(tuple[0]) # 输出元组的第一个元素

print(tuple[1:3]) # 输出第二个至第三个的元素

print(tuple[2:]) # 输出从第三个开始至列表末尾的所有元素

print(tinytuple * 2) # 输出元组两次

print(tuple + tinytuple) # 打印组合的元组

----字典--------

dict = {}

dict['one'] = "This is one"

dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print(dict['one']) # 输出键为'one' 的值

print(dict[2]) # 输出键为 2 的值

print(tinydict) # 输出完整的字典

print(tinydict.keys()) # 输出所有键

print(tinydict.values()) # 输出所有值

----Set----------

** Python3新加入的

student = {'Tom','Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

print(student) #重复的元素被自动去掉

if('Rose' in student) :

print('Rose 在集合中')

else :

print('Rose 不在集合中')

# set可以进行集合运算

a = set('abcde')

b = set('abcfg')

print(a)

print(b)

print(a - b) # a和b的差集

print(a | b) # a和b的并集

print(a & b) # a和b的交集

print(a ^ b) # a和b中不同时存在的元素

----bytes类型--------------

** Python3新添加的

b = b'china'

print(type(b)) #查看类型

s = b.decode() #转换为字符串

print(s)

b1 = s.encode() #转换为bytes类型

print(b1)

----可变与不可变------------------------

在 python 中，string, tuple, 和 number 是不可更改的对象，而 list,dict 等则是可以修改的对象

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a

可变类型：变量赋值 list=[1,2,3,4] 后再赋值 list[2]=5 则是将llist的第三个元素值更改， list本身没有动，只是其内部的一部分值被修改了

====运算符======================================

print(2**3) #8 求幂

print(10//3) #3 求整数商

print(1/2) #0.5，和其他语言有所不同

a=100

a+=1 #没有a++

print(a)

关系运算符： > < == != (<>在Python3中不支持) >= <=

----逻辑运算符----------

# 0为假，非0为真

a = 10

b = 20

if (a and b):

print("1 - 变量 a 和 b 都为 true")

else:

print("1 - 变量 a 和 b 有一个不为 true")

if (a or b):

print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")

else:

print("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值

a = 0

if (a and b):

print("3 - 变量 a 和 b 都为 true")

else:

print("3 - 变量 a 和 b 有一个不为 true")

if (a or b):

print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")

else:

print("4 - 变量 a 和 b 都不为 true")

if not (a and b):

print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")

else:

print("5 - 变量 a 和 b 都为 true")

----成员运算符----------

#in、not in

a = 1

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 中")

----身份运算符-----------

# is 是判断两个标识符是不是引用自一个对象，x is y 类似 id(x) == id(y)

# is 与 == 区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等

a = 20

b = 20

print(a is b)

print(a is not b)

# 修改变量 b 的值

b = 30

print(a is b)

print(a is not b)

PS:

** is在Python命令行中比较特殊

为了提高内存利用效率对于一些简单的对象，如一些数值较小的int对象，python采取重用对象内存的办法，如指向a=2，b=2时，由于2作为简单的int类型且数值小，python不会两次为其分配内存，而是只分配一次，然后将a与b同时指向已分配的对象

>>> c=20

>>> d=20

>>> c is d

True

如但果赋值的不是2而是较大的数值，情况就不一样了：

>>> c=5555

>>> d=5555

>>> c is d

False

====条件=========================================

num = 5

if num == 3:

print('boss')

elif num == 2:

print('user')

elif num == 1:

print('worker')

elif num < 0:

print('error')

else:

print('roadman')

PS:

python 并不支持 switch 语句

====代码组=======================================

** Python与其他语言最大区别是，Python代码块不使用大括号 {}

** Python最具特色的就是用缩进来写模块

** 缩进相同的一组语句构成一个代码块，我们称之代码组

** 像if、while、def和class等首行以关键字开始，以冒号结束，该行之后的一行或多行代码构成"代码组"

** 我们将首行及后面的代码组称为一个"子句"(clause)

** 缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行!!!

例如：

if expression :

suite #代码组

elif expression :

suite

else :

suite

例如：(注意：没有严格缩进，在执行时会报错)

** 通过coding属性支持中文(在不支持中文时，加上该句)

** 下面代码会报缩进错误IndentationError

#!/usr/bin/python

# -*- coding: UTF-8 -*-

if True:

print("aaa")

print("True")

else:

print("bbb")

print("False") #注意缩进，只要对齐就行，至于用空格还是用tab对齐没区别

PS：

有些环境下，tab和空格不可以混用，有些环境下可以

因此建议在每个缩进层统一使用'单个制表符'、'两个空格'或'四个空格'，尽量不要混用，以避免不必要的麻烦

====while===========================================

count = 0

while count < 10 :

#while (count < 10) : #也可以

print('The count is:', count)

count = count + 1

----while … else-------

** 循环条件为false时，执行else语句块，只执行一次

count = 0

while count < 5:

print(count, " is less than 5")

count = count + 1

else:

print(count, " is not less than 5")

----continue-----------

i = 1

while i < 10:

i += 1

if i%2!=0 : # 非双数时跳过输出

continue

print(i) # 输出双数2、4、6、8、10

----break---------------

i = 1

while True :

print(i)

i += 1

if i > 10: # 当i大于10时跳出循环

break

----for-----------------

for letter in 'Python' :

print('当前字母 :', letter)

-------------

fruits = ['banana', 'apple', 'mango']

for fruit in fruits :

print('当前水果 :', fruit)

-------------

** 通过序列索引迭代

fruits = ['banana', 'apple', 'mango']

for index in range(len(fruits)):

#for index in range(3): #效果相同，即(1,2,3)

print('当前水果 :', fruits[index])

----for...else----------

for num in range(2,10): # 迭代 2 到 10 之间的数字

for i in range(2,num): # 根据因子迭代

if num%i == 0: # 确定第一个因子

j=num/i # 计算第二个因子

print('%d 等于 %d * %d' % (num,i,j))

break # 跳出当前循环

else: # 循环的 else 部分

print(num, '是一个质数')

----pass-----------------

** pass语句不做任何事情，一般用做占位

for letter in 'Python':

if letter == 'h':

pass

print('这是 pass 块')

else:

print('当前字母 :', letter)