- 7 mins
Python Note CN

Python 学习笔记 01

Table of Contents

编程语言分类

编译型和解释型

编译型语言（c，c++，go，swift）
- 优点：运行时不需要编译，执行效率高，可以脱离语言环境独立运行
- 缺点：平台兼容性差，需要根据运行的操作系统环境编译成不同的可执行文件

解释型语言（python，ruby，php，perl）
- 优点：平台兼容性好，代码可以直接修改，不用停机维护
- 缺点：每次运行都要解释，性能不如编译型语言

编译器：把源程序的语句都编译成机器语言，保存成二进制文件，运行时直接运行机器语言，速度很快
解释器：执行程序时，才一条条解释成机器语言给计算机执行，运行速度不如编译后的程序快

静态语言和动态语言

动态类型语言
 运行期间才做数据类型检查的语言，第一次赋值给变量时，在内部将数据类型记录下来，python和ruby就是动态类型语言		
静态类型语言
 在编译期间检查数据类型的语言，写程序时要声明所有变量的数据类型，c/c++就静态类型语言代表

强类型定义语言和弱类型定义语言

强类型定义语言
 一个变量被指定了某个数据类型，需要强制转换才能更改类型，速度不如弱类型语言，但是严谨性能避免许多错误
弱类型定义语言
 数据类型可以被忽略的语言，与强类型语言相反，一个变量可以赋不同数据类型的值

因此 Python是一门解释型动态强类型语言

Python 优缺点

优点

开发效率高
高级语言（不需要考虑底层细节），
可移植性（基本不需要修改就能运行在所有系统平台上），
可扩展性（python里面加入c，c++），
可嵌入性（可以把python嵌入到c，c++）

缺点

速度慢
代码不能加密（因为是解释型语言，源码都是明文形式的）
线程不能利用多CPU问题

Python 解释器

Python的解释器很多，但使用最广泛的还是CPython。如果要和Java或.Net平台交互，最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。

简述 Python 运行过程 

1.python程序首次运行时，编译结果保存在位于内存的pycodeobject中，当python程序运行结束时，python解释器则将pycodeobject写会pyc文件中
2.python程序第二次运行时，首先程序会在硬盘中找pyc文件，找到就直接载入否则重复上面过程
PS:pyc是pycodeobject的持久化保存方式

变量定义规则

- 变量名只能是 字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- 以下关键字不能声明为变量名
	['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

数据类型

数字

  • int（整型） 在32位机器上，整数的位数为32位，64位机器上，整数的位数为64位
  • long（长整型）
  • float（浮点型）
  • complex（复数） 注意： Python3.x 去除了 long 类型，现在只有一种整型 int，表示为长整型。
>>> i = 5  # 整型
>>> type(i)
<class 'int'>
>>> f = 2.5  # 浮点型
>>> type(f)
<class 'float'>
>>> c = 1+2j  # 复数
>>> type(c)
<class 'complex'>

布尔值

真或假/1或0

字符串

字符串是 Unicode 字符的序列

常用操作：移除空白，分割，长度，索引，切片

>>> a = "topaz"				
>>> a.capitalize()		#首字母大写
'Topaz'
>>> a = "Topaz"
>>> a.casefold()		#大写都变成小写
'topaz'				
>>> a.count("t")		#统计t出现的次数
1
>>> a.encode()			#将字符串编码成bytes格式
b'topaz'
>>> a.endswith("z")		#判断是不是以z为结尾
True
>>> a.find("o")			#查找o，返回o的索引
1
>>> a.center(50,"-")	#输出

PS：格式化输出字符串是%s，整数%d，浮点数%f

列表

列表是有序的元素序列

常用操作：索引，切片，追加，删除，长度，切片，循环

###定义列表
>>> a = ['youxi','baga','yamei','peipeipei']

###插入
>>> a.insert(1,'nani')							
>>> a
['youxi', 'nani', 'baga', 'yamei', 'peipeipei']

###删除
>>> del a[4]									
>>> a
['youxi', 'nani', 'baga', 'yamei']
>>> a.remove('yamei')							#删除指定元素
>>> a
['youxi', 'nani', 'baga']

>>> a.pop()										#删除最后一个
'baga'
>>> a
['youxi', 'nani']

###扩展
>>> b = ['xixi','lala','bo']					
>>> a.extend(b)
>>> a
['youxi', 'nani', 'xixi', 'lala', 'bo']

###统计，排序，反转 & 获取下标
>>> a.count("nani")		#统计
1

>>> a.sort()		#排序，Python3.x不同类型不能放在一起排序了		
>>> a
['bo', 'lala', 'nani', 'xixi', 'youxi']

>>> a.reverse()			#反转					
>>> a
['youxi', 'xixi', 'nani', 'lala', 'bo']

>>> a.index("xixi")		#获取下标
1

字典

字典是键值对的无序集合 & key必须是唯一的,so 天生去重

常用操作：索引，新增，删除，键、值、键值对，循环，长度

info = {'你大舅': '你舅', '你二舅': '你舅', '高板凳': '木头', '低板凳': '木头'}
###增加
>>> info['topaz']='socute'
>>> info
{'topaz': 'socute','你大舅': '你舅', '你二舅': '你舅', '高板凳': '木头', '低板凳': '木头'}

###修改
>>> info['topaz']= 'piupiu'
>>> info
{'topaz': 'piupiu','你大舅': '你舅', '你二舅': '你舅', '高板凳': '木头', '低板凳': '木头'}

###两种删除方式
>>> info.pop("你大舅")
>>> info
{'你二舅': '你舅', 'topaz': 'piupiu', '高板凳': '木头', '低板凳': '木头'}

>>> del info["你二舅"]
>>> info
{'topaz': 'piupiu', '高板凳': '木头', '低板凳': '木头'}

###三种获取方式
>>> 'topaz' in info		#获取方法一
True

>>> info['topaz']		#获取方法二
'piupiu'
>>> info['topaz1']		#此种方式获取下字典里不存在的值，会报错
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'topaz1'

>>> info.get('topaz')	#获取方法三
'piupiu'
>>> info.get('topaz1')	#此种方式获取下字典里不存在的值，不会报错而是返回None，因此推荐使用
>>> a = info.get('topaz1')
>>> print(a)
None

元组

元组与列表相同，也是有序序列，唯一的区别是元组是不可变的

ages = (11, 22, 33, 44, 55) 或 ages = tuple((11, 22, 33, 44, 55))

集合

集合是一个无序的，不重复的数据组合，用 {} 标识，内部元素用逗号分隔，它的主要作用如下：

  • 去重，把一个列表变成集合，就自动去重了
  • 关系测试，测试两组数据之前的交集、差集、并集等关系
s = set([3,5,9,10])      #创建一个数值集合  
t = set("Hello")         #创建一个唯一字符的集合  
a = t | s          # t 和 s的并集  
b = t & s          # t 和 s的交集  
c = t – s          # 求差集（项在t中，但不在s中）    
d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  
t.add('x')            # 添加一项  
s.update([10,37,42])  # 在s中添加多项  
t.remove('H')  			#使用remove()可以删除一项
len(s)  			#set 的长度  
x in s  			#测试 x 是否是 s 的成员  
x not in s  		#测试 x 是否不是 s 的成员  
s.issubset(t) 或 s <= t 	#测试是否 s 中的每一个元素都在 t 中  
s.issuperset(t) 或 s >= t  #测试是否 t 中的每一个元素都在 s 中
s.union(t) 或 s | t   	#返回一个新的 set 包含 s 和 t 中的每一个元素
s.intersection(t) 或 s & t  #返回一个新的 set 包含 s 和 t 中的公共元素  
s.difference(t)  或	s - t  	#返回一个新的 set 包含 s 中有但是 t 中没有的元素  
s.symmetric_difference(t)  或 s ^ t  #返回一个新的 set 包含 s 和 t 中不重复的元素    
s.copy()  			#返回 set “s”的一个浅复制

运算

  • 算数运算：+ - * / % ** //
  • 比较运算： == != <> > < <= >=
  • 赋值运算：= += -= *= /= %=
  • 逻辑运算：and，or，not
  • 成员运算：in ，not in
  • 身份运算：is ，is not
  • 位运算：& ^
  • 运算符优先级

Demo

根据上面的知识我们就可以写一个三级菜单啦~ 要求: 打印省、市、县三级菜单 可返回上一级 可随时退出程序

menu = {
	'北京':{
		'海淀':{
			'五道口':{
				'soho':{},
				'网易':{},
				'google':{}
			},
			'中关村':{
				'爱奇艺':{},
				'汽车之家':{},
				'youku':{},
			},
			'上地':{
				'百度':{},
			},
		},
		'昌平':{
			'沙河':{
				'':{},
				'北航':{},
			},
			'天通苑':{},
			'回龙观':{},
		},
		'朝阳':{},
		'东城':{},
	},
	'上海':{
		'闵行':{
			"人民广场":{
				'炸鸡店':{}
			}
		},
		'闸北':{
			'火车战':{
				'携程':{}
			}
		},
		'浦东':{},
	},
	'山东':{},
}
exit_flag = False
# current_layer = menu
layers = [menu]     #这个主要用于返回上一层用

while not exit_flag:
	# print('最初的起点',menu)
	for k in menu:
		print(k)        #打印出当前字典的key
	choice = input(">>:").strip()
	if choice == "b":           #回到上一层目录，第一次肯定走else，之后可以返回上一级
		menu = layers[-1]       #取出最后一个就是上一层的目录
		print("change to laster", menu)
		layers.pop()           
	elif choice not  in menu:
		print("不正确选项")
		continue   #没有选项，停留在当前目录
	else:                                 #选择了（进入下一层目录）
		layers.append(menu)
		menu = menu[choice]                #保存起选择的值，返回到最初的起点

Related Posts

Topaz

Topaz

Always keep learning.

comments powered by Disqus
rss facebook twitter github youtube mail spotify instagram linkedin google pinterest medium vimeo