编译型语言和解释型语言

• 有的编程语言要求必须将所有源代码一次性转换成二进制指令，也就是可执行程序，比如 C、C++、Golang、汇编语言等都属于编译型语言，使用的转换器叫做编译器。
• 有的编程语言可以一边执行一边转换，需要那些源代码就转换哪些源代码，不会生成可执行程序，比如Python、JavaScript、PHP和Shell等，这类编程语言称为解释型语言，使用的转换器称为解释器。

编译器和解释器简单来说都是翻译工具。

编译型语言特点：

• 拥有可执行程序后可以随时运行，不需要重新编译，即“一次编译，无限次运行”，因此编译型语言可以脱离开发环境运行（什么是开发环境？）；

• 编译型语言通常是不能跨平台的，也就是不能再不同的操作系统之间随意切换。不能跨平台表现在两方面：

  1：可执行程序不能跨平台。不同的操作系统对可执行程序的内部结构有着截然不同的要求，彼此之间不能兼容；

  相同的也可能不行，比如x64程序不能在x86平台上运行。

  2：源代码不能跨平台。不同平台支持的函数、类型、变量等可能都不同，基于某个平台编写的源代码一般不能拿到另一平台上直接运行。比如在C中，Windows中的 Sleep() 函数在 Linux下是 sleep() ，且前者单位为毫秒，后者单位为秒。Windows 64位和Linux中C的 long 类型占用的字节分别为 4 和 8 。

  所以编译型语言的主要缺点就是可移植性差。

解释型语言特点：

• 效率较编译型语言低。因此底层功能常用C/C++，而应用层面才会用解释型语言。
• 运行解释性语言时，我们始终都需要源代码和解释器，因此它无法脱离开发环境。
• “一次编写，到处运行”。在不同的平台下，解释器会将相同的源代码转化为不同的机器码，解释器帮助我们屏蔽了不同平台之间的差异性。

模块和包

可以类比为C/C++中的头文件，但与头文件不同的是，任何python程序都可以作为其他python程序的模块。用 import 关键字可以引入一个模块。比如：

1
2
3
4
5
6

def say()
	print("hello")
#上述文件命名为hello.py,与下面的名为say.py的文件放置在同一目录下
import hello
hello.say()
#会输出hello

这里面 hello.py 实际上就是一个自定义的模块，调用模块中的函数时，语法为 模块名.函数名 。

基础语法

1：无需加分号。

2：注意缩进：

1
2
3
4
5

if 5>2
	print("hello")
#注意下面的语句会报错
if 5>2
print("hello")

3：没有声明变量的命令。

4：字符串用 '' 和 "" 都可以。

5：变量命名规则同 MATLAB。

6：一行中多个变量赋值：

1
2
3
4

a,b,c="x","y","z"
print(a)
print(b)
print(c)

7：两个字符串拼接用 +（文本与变量、变量与变量之间都可），数字之间用 + 是正常运算：

1
2
3

a=world
print("hello "+a)#会输出hello world
print(a+a)#会输出worldworld

8：函数，用关键字 def 即可，注意缩进：

1
2

def myfunc()
	......

9：全局变量与局部变量同C/C++。在函数内部创建全局变量用 global 关键字，在函数内部修改全局变量需要加上 global 关键字：

1
2
3
4
5
6
7
8

x='a'

def myfunc()
	global x
 	x='b'
 	print(x)
myfunc()#输出b
print(x)#输出b

10: 输入：

1

x=input("一些描述")

input() 函数默认返回字符串，如果使用输入的数字，需要用对应的类型进行转换：

1
2

x=int(input())
x=float(input())

数据类型

1：用 type() 获得数据类型。

2：指定数据类型时可以用 x=name(content)，如

1

x=str(”hello world“)

3：复数 complex 用 j 作为虚部。

4：用 int(data), flaot(data), complex(data) 进行数据类型转换，注意无法将复数转化为其他类型的数据。

5：bool() 也可以用来评判数据为 True 还是 False，除空字符 "" '' 、0 和空列表 (),[],{} 外，bool() 总是返回 True .

字符串

1：用三个引号可以将多行字符串赋值给变量，单引号与双引号均可：

1
2
3
4

a="""aa
bb
cc"""
print(a)#换行符会被保留

2：Python中的字符串是表示unicode字符的字节数组，但是python不像 C/C++ 那样有字符类型，单个字符就是长度为1的字符串。

1
2
3
4
5

a="abcdefg"
print(a[1])#输出b
print(a[2:5])#输出cdef
print(a[-5:-2])#输出cde,输出的字符的范围为左闭右开区间
print(a[-3])#输出倒数第三个字母

3：字符串的内置方法

1
2
3
4
5
6

a=" abcdefg "
a.strip()#删除开头和结尾的空白字符
a.lower#返回小写的字符串
a.upper#返回大写的字符串
a.replace("要替换的部分","用来替换的部分")#replace()方法是用另一字符串来替换字符串，对长度无要求
a.split("分隔符")#根据分隔符输出每一部分，分隔符是自己定义的

不能直接用 + 组合字符串和数字，但是可以用 format() 方法。format() 方法接受传递的参数，格式化它们并且将它们放在占位符 {} 所在的字符串中：

1
2
3

str="I am {} years old"
age=19
print(str.format(age))#输出I am 19 years old

4：一些关键词

可以用 in 或者是 not in 来判断字符串种是否存在特定短语或字符。

1
2
3

str="China is a great country"
x="ina" in str
print(x)#会输出布尔类型的值

5：一些函数

1

len(str)#获得str的长度

运算符

很多运算符与C/C++几乎都一样，下面是一些特别的例子：

一些数据结构

列表

列表很像STL中的 vector，是有序且可以更改的集合。可以代替C/C++中的数组。

1：创建列表：

1
2
3

list1=[1,2,3]
list2=["ab","bc","ac"]
list3=list(("aa","bb","cc"))#注意有两对括号

输出 list1 和 list2 会将元素连同方括号与引号都输出，同时只会输出单引号。

2：索引与字符串（数组）的索引规则相同。利用索引可以更改特定项目的值。

3：可以用 in 关键字。包括后面的元组、集合和字典都可以使用该关键字用来判断某个元素是否在其中。

4：可以用 len() 函数。包括后面的元组、集合和字典都可以用该函数求出它的长度/元素个数。

5：增：

• 用 insert(loc, element) 将 element 插入作为第 loc+1 个位置；
• append(element) 方法在列表的末尾增添元素 element；同样也能添加另一个列表

6：删：

• remove(element) 方法删除指定的项目 element；
• pop(num) 方法删除指定的索引，若未指定索引，则删除最后一项；
• del list1[num] 删除指定的索引；
• del list1 删除整个列表（删除后使用该变量会报错：NameError: name 'list1' is not defined.）；
• clear() 方法清空列表得到空列表。

7：复制列表

• 直接赋值：list2=list1
• 用 copy() 方法： list2=list1.copy()
• 用 list() 构造函数： list2=list(list1)

8：合并列表

• 用运算符 +
• 用 extend() 方法： list2.extend(list1)

元组

元组是有序且不可更改的集合，因此也就不能增删补以及拷贝赋值。

1：创建

1
2
3

tuple1=("apple",)#必须要加逗号，否则不能被识别为元组，而会被识别为字符串
tuple2=("1","2","3")
tuple3=(1,2,3)

若

1
2
3

tuple0=("1")
print(type(tuple2))
#会输出<class 'str'>

2：索引与字符串（数组）的索引规则相同。只能利用索引访问元的值。如果想要更改元组中的值，可以把元组转化成列表（用 list() ），再用 tuple() 转化为元组。

3：不能删除元组中的项目，但是可以用 del 关键字删除元组。效果同列表。

4：常用方法：

5：合并只能用 +。

6：和列表一样可以用 tuple() 构建元组。

集合

1：集合是无序的，不能像前面三种结构那样用下标进行索引，只能遍历或用关键字 in。

2：集合中的元素无法更改，但是可以增加新元素。

1
2
3
4

set1={"1","2","3"}#也可以用set()构造集合，类似于前面的数据类型
#set1=set(("1","2","3"))
set1.add("4")#在集合中添加一项
set1.upsate(["5","6","7"])#在集合中添加多个元素，要用中括号

3：也可以删除元素。用 remove() 方法或者 discard() 方法来删除指定元素，括号内填写要删除的元素；用 pop() 方法来删除随机元素并返回删除的元素； clear() 方法删除集合中的所有元素得到空集合；del 关键字删除集合。

如果要删除的项目不存在， 用 remove() 会报错，而 discard() 不会（不会输出任何信息）。

4： union() 方法返回两个集合的并集，update() 方法可以将一个集合中的元素插入到另一个集合中（得到的也是并集，会直接赋值给使用该方法的集合）。

字典

1：创建。

1
2
3
4
5
6
7

dict1={
key1: value1,
key2: value2,
key3: value3,
...
}#key只能为字符串,注意逗号
dict1=dict(key1=value1,key2=value2,...)#注意用等号而不是冒号

2：访问。

1
2
3

x=dict1[key1]
x=dict1.get(key1)
dict1[key1]=value4#将key1对应的值更为value4

3：循环遍历字典返回key，用 values() 方法返回value，用 items() 方法遍历 key 和 value（需要两个循环变量）。

1
2

for x,y in dict1.items()
	print(x,y)

4：删。

1
2
3
4

dict1.pop(key1)#pop()方法删除指定key的item
dict1.popitem()#popitem()方法删除最后一项
del dict1[key1]#del关键字也可以删除指定key的item,同时也可以删除整个字典
dict1.clear()#清空字典

5：复制字典。

dict2=dict1 表示 dict2 是 dict1 的引用，更改 dict1 也会造成 dict2 的更改 ，复制的正确方法：

1
2

dict2=dict1.copy()
dict2=dict(dict1)

分支与循环

分支

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

if b>a: print("b>a")
#   
if b>a:
    print("b>a")
else:#不要忘记冒号
    print("b<=a")
#    
if b>a:
    print("b>a")
elif b==a:
    print("b==a")
else:
    print("b<a")
#
print("b>a") if b>a else print("b<=a")#语句放在前面单行执行
#
if b>a:
	pass#空的语句会报错,用pass来避免

循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#while循环
while condition:
	#code
#for循环:用于遍历序列,包括list,tuple,set,dict和string
for x in list1:
	#code
#range()函数返回一个数字序列,且默认从0开始
for x in range(10):#x范围为0到9
	#code
for x in range(3,10):#x范围为左闭右开区间,即x属于与3~9
	#code
for x in range(3,50,6):#第三个参数指定增量
	#code
#最后加一句else可以在循环结束时执行一些语句
#和if一样同样可以用pass

C/C++中的 break 和 continue 在Python中依然可以用。

函数

1：默认参数。

1
2
3
4
5

def myfunc(country="China"):#默认参数用=
    print("I am from "+country)

myfunc()#调用不带参数的函数时使用默认参数
myfunc("England")#调用的函数有参数时使用该参数

2：参数传入函数后数据类型不变。

3：关键字参数

1
2
3
4

def myfunc3(child3,child1,child2):
    print("The youngest children is "+child3)

myfunc3(child1="a",child2="b",child3="c")

在调用时指定参数的值，无需考虑顺序。

4：任意参数。

1
2
3

def myfunc(*kids)#加上*表明参数数目未知
	print(kids[2])#此时可以把kids当作tuple
myfunc(1,2,3,4)#调用后输出3

函数将接受一个类型为tuple的参数，并可以用它的索引方式访问元素。

lambda匿名函数

1

函数名=lambda 参数:表达式

比如：

1
2

f=lambda x,y:x+y#多个参数时加逗号
print(f(2,3))#输出5

或者用在 return 语句中：

1
2
3
4

def myfun4(n):
    return lambda a:a*n#类似于一个“嵌套函数”
subfunc=myfun4(2)用myfunc4定义一个新的函数
print(subfunc(2))

但是如果：

1
2
3

def myfun4(n):
    return lambda a:a*n
print(myfun4(2))

参数数量不够，会输出

1

<function myfun4.<locals>.<lambda> at 0x000001E7B43AEEF0>