Python基本语法

Python基本语法

1. 输出语句

​* print()
​* 关键字
​	* nonloacl  用来声明外层的局部变量
​	* global	用来声明全局变量

2. if...else语句

* if 5 > 2:
​	print("You are right!")
​  else:
​	print("You are wrong!")
​* 注：缩进一定要，否则会出错
​* 注2：if 语句不能为空，但是如果您处于某种原因写了无内容的 if 语句，请使用 pass 语句来避免错误

3. 注释

1. 单行注释以 # 开头 
	* 快捷键：Ctrl + /
2. 多行注释 """ """ 中间	

4. 变量

1. x = 5
2. y = "Hello Word!"
​* 注：Python中没有声明变量的命令，直接用即可
​* Python 允许您在一行中为多个变量赋值：
​	* 实例
​	x, y, z = "Orange", "Banana", "Cherry"
​	print(x)
​	print(y)
​	print(z)
​* 在一行中为多个变量分配相同的值：
​	* 实例
​   x = y = z = "Orange"
​	print(x)
​	print(y)
​	print(z)
​3. 可变变量
​	* 先导入io
​	import io
​	s = 'hello'
​	sio = io.StringIO(s)
​	print(sio.getvalue())		#结果为 'hello'
​	sio.seek(4)					#把光标移到第5个位子
​	sio.write("r")				#修改第5个位置的字符
​	print(sio.getvalue())		#结果为 'hellr'

5. 数据类型

1. Python 默认拥有以下内置数据类型：
​	文本类型：	str
​	数值类型：	int, float, complex
​	序列类型：	list, tuple, range
​	映射类型：	dict
​	集合类型：	set, frozenset
​	布尔类型：	bool
​	二进制类型：	bytes, bytearray, memoryview
​2. 可以使用 type() 函数获取任何对象的数据类型：
​	* 实例
​	x = 10
​	print(type(x))
​3. Python 随机数
​	* Python 没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块，可用于生成随机数：
​		* 实例
​		导入 random 模块，并显示 1 到 9 之间的随机数：
​		import random
​		print(random.randrange(1,10))
​4. Python 字符串
​	1. 字符串变量可以使用单引号或双引号进行声明
​		print("Hello")
​		print('Hello')
​	2. 裁剪
​		* 指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分
​			* 实例
​			获取从位置 2 到位置 5（不包括）的字符：
​			b = "Hello, World!"
​			print(b[2:5])
​			结果是：llo
​		* 使用负索引从字符串末尾开始切片：
​			* 实例
​			从倒数第5个字符开始，到倒数第2(不包含)个字符：
​			b = "Hello, World!"
​			print(b[-5:-2])
​			结果：orl
​	3. 内置函数
​		1. len() 函数返回字符串的长度：
​			a = "Hello, World!"
​			print(len(a))
​		2. strip() 方法删除开头或结尾的空白字符：
​			a = " Hello, World! "
​			print(a.strip())     # returns "Hello, World!"
​		3. lower() 返回小写的字符串：
​			a = "Hello, World!"
​			print(a.lower())
​		4. upper() 方法返回大写的字符串：
​		5. replace() 用另一段字符串来替换字符串：
​			a = "Hello, World!"
​			print(a.replace("World", "Kitty"))
​		6. split() 方法在找到分隔符的实例时将字符串拆分为子字符串：
​			a = "Hello, World!"
​			print(a.split(",")) # returns ['Hello', ' World!']
​	4. 检查字符串
​		* 如需检查字符串中是否存在特定短语或字符，我们可以使用 in 或 not in 关键字。
​		* 实例
​			检查以下文本中是否存在短语 "ina"：
​			txt = "China is a great country"
​			x = "ina" in txt
​			print(x)
​	5. 字符串格式：我们不能像这样组合字符串和数字，但是我们可以使用 format() 方法组合字符串和数字！
​		* 实例
​			age = 63
​			txt = "My name is Bill, and I am {}"
​			print(txt.format(age))
​			* 注：format() 方法接受不限数量的参数，并放在各自的占位符中，可以使用索引号 {0} 来确保参数被放在正确的占位符中

6. 运算符

1. Python 逻辑运算符
​	and  or  not
​2. Python 身份运算符
​	is    is not
​3. Python 成员运算符
​	in    not in
4. 算术运算符中的幂运算和整除运算符：
      1. ** 
         x**y返回x的y次幂
         2**3 的结果为8
      2. // 
         返回商的整数部分
         9//2的结果为4

7. Python 集合（数组）

* Python 编程语言中有四种集合数据类型：
​   1. 列表（List）是一种有序和可更改的集合。允许重复的成员。
        列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写[]。
​			* a = [10,20,40,30]
​			* a.sort()		#默认升序排列 [10,20,30，40]
​			* a.sort(reverse=True)		#降序排列 [40,30,20,10]
​			* import random
​			* random.shuffle(a)		#打乱顺序
			* a.append(60)        #向最后添加元素
			* a[3]        #30
			* del a[2]    #40被移除
        遍历列表元素
                    list = ['12','你好','张三','hello']
                    fot i in range(len(list)):
                      print(list[i])
                    运行结果为：12  你好  张三  hello

                    list = ['12','你好','张三','hello']
                    for index,value in enumerate(list):
                      print("第%d个元素的值是 %s" %(index,value))
                    运行结果为：
                    第0个元素的值是 12
                    第1个元素的值是 你好
                    第2个元素的值是 张三
                    第3个元素的值是 hello
    2. 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。
​       元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。
    3. 集合（Set）是一个无序和无索引的集合。没有重复的成员。
       集合是无序和无索引的集合。在 Python 中，集合用花括号编写。
​       * 集合的并交差
​			* a|b 或 a.union(b)  		#并集
​			* a&b 或 a.intersection(b) 	#交集
​			* a-b 或 a.difference(b)		#差集
    4. 字典（Dictionary，及键值对）是一个无序，可变和有索引的集合。没有重复的成员。
​		* 字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。
​		* 创建并打印字典：
​			*1.	thisdict =	{
​				  "brand": "Porsche",
​				  "model": "911",
​				  "year": 1963
​				}
​				print(thisdict)
​			*2.	k = ['name','age','job']
​				v = ['zhagnsan',18,'student']
​				d = dict(zip(d,v))
​				print(d)
​		* 由键访问值
​			1. a['name']
​			2. a.get('name')
​		* 列出所有键值对或键或值
​			* a.items()		#结果为所有的键值对
​			* a.keys()		#结果为所有键
​			* a.values(）	#结果为所有值

8. Python 循环

☆ For循环
​1. 打印 fruits 列表中的每种水果：
​	fruits = ["apple", "banana", "cherry"]
​	for x in fruits:
​	    print(x)
​2. 循环遍历单词 "banana" 中的字母
​	for x in "banana":
​	    print(x)
​3. 使用 range() 函数：
​	for x in range(6):
​		print(x)
​	* 注：
​		1. range(6) 不是 0 到 6 的值，而是值 0 到 5。
​		2. range(2, 6)，这意味着值为 2 到 6（但不包括 6）
​		3. range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值：range(2, 30, 3)
​4. For 循环中的 Else：for 循环中的 else 关键字指定循环结束时要执行的代码块：
​	* 实例
​		for x in range(6):
​			print(x)
​		else:
​		    print("Finally finished!")

☆ while 循环
        i = 1
        sum = 0
        while i < 11:
          sum += i
          i += 1
        print(sum)

9. Python 函数：在 Python 中，使用 def 关键字定义函数

​1. 定义
​	*  def my_function():
​	     print("Hello from a function")
​	*  def my_function(fname):
             print(fname + " Gates")
​	* 默认参数 ：如果我们调用了不带参数的函数，则使用默认值(默认值参数要放在其他参数后面)
​		def my_function(country = "China"):
​		    print("I am from " + country)
​		my_function("India")
​		my_function()
​	* 可变参数
​		1. *param(一个星号)，将多个参数收集到一个元组对象中
​		2. *param(两个星号)，将多个参数收集到一个字典对象中
​2. 使用
​	my_function()
​3. 特点
​	* 函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误
​4. eval函数
​	* eval("print('123')")		# 结果为 123
​5. 装饰器（给已有函数添加新功能）
​	* 实例
​		[from functools import wraps]		#[]为可不写内容，
​		def wrapper(func):			#装饰器函数，func是被装饰器函数
​			[@wraps(func)]
​			def inner(*args,**kwargs)
​				"在被装饰的函数之前要做的事"
​				ret = func(*args,**kwargs)
​				"在被装饰的函数之后要做的事"
​				return ret
​			return inner
​		@wrapper					#语法糖  @装饰器函数名
​		def func(a,b):				#被装饰函数
​			print("你好"，a,b)
​			return "新年好"
​	* @property 用于把调用方法时改为调用变量
​6. 生成器
​	1. 把return换成yield，yield只用于生成器函数，后跟返回值（return后函数结束，yield之后函数不会结束）
​	2. ret = func()		#是把ret设置成生成器
​	3. print(ret)		#结果为 生成器类型
​	4. print(ret.__next__())	#结果是执行了func函数之后的值
​7. isinstance(obj,cla)检查obj是否是类cla的对象
​8. issubclass(sub,super)检查sub类是否是super类的派生类
​9. 几个内置方法
​	1. __str__ 返回调用这个方法的对象的内存地址
​	2. __repr__

10. Python Lambda

​​1. 语法
​	lambda 形参 : 表达式
​2. 实例
​	1. 一个 lambda 函数，它把作为参数传入的数字加 10，然后打印结果：
​		x = lambda a : a + 10
​		print(x(5))
​	2. 一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果：
​		x = lambda a, b : a * b
​		print(x(5, 6))

11. Python 类和对象

* 使用名为 x 的属性，创建一个名为 MyClass 的类：
​	class MyClass:
​	    x = 5
​* 创建一个名为 p1 的对象，并打印 x 的值：
​	p1 = MyClass()
​	print(p1.x)
​* 实例
​      class Person:
        def __init__(self, name, age):
​		    self.name = name
​		    self.age = age
        def myfunc(self):
​		    print("Hello my name is " + self.name)
​	p1 = Person("Bill", 63)
​	p1.myfunc()
​	提示：self 参数是对类的当前实例的引用，用于访问属于该类的变量。它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数。
​* 注：类定义不能为空，但是如果您处于某种原因写了无内容的类定义语句，请使用 pass 语句来避免错误。
​1. 类方法  方法前加@classmethod 
​2. 静态方法	方法前加@staticmethod
3. 私有方法	def __方法名
4. 接口类
    from abc import abstractclassmethod,ABCMeta
    class Animal(metaclass=ABCMeta):
        @abstractclassmethod
        def eat(self):
​           pass

12. 打开文件 w写 r读 最后调用close方法关闭文件

​* 一直读入文件
​	def tail(filemane):
​		file = open(filename,encoding='utf-8')
​		while True:
​			line = file.readline()
​			if line.strip():
​				yield line.strip()
​	g = tail('file')
​	for i in g:
​		print('*****',i)

13. 模块

​* re模块	  正则模块
​	1. findall		#找到所有字符串
​	2. search		#从前往后找到一个就返回
​		ret = re.search('a','I am a good man')
​		ret.group()	#得到值
​	3. match

​* collections模块
​	1. namedtuple		#可命名元组
​		from collections import namedtuple	
​		Point = namedtuple('point',['x','y'])
​		p = Point(1,2)
​		print(p.x)
​		print(p.y)
​	2. deque 		#双端队列
​		import queue		#队列
​		q = queue.Queue()
​		q.put(10)
​		q.put(5)
​		print(q.get())		#结果为10
​		print(q.qsize())	#队列长度为2
​		form collections import deque		#双端队列
​		dq = deque([1,2])
​		dq.append()		#从后面放数据
​		dq.appendleft()	#从前面放数据
​		dq.pop()			#从后面取数据
​		dq.popleft()		#从前面取数据
​	3. time模块
​		import time
                time.ctime()	#获取当前时间的字符串
​		time.sleep()
​		time.time()    #时间戳，从1970年01月01日00:00起至今的总秒数
​		struct_time = time.localtime(time.time())          #将时间戳转换成当地时区时间
                print(time.strftime("%Y-%m-%d %X"),struct_time)		#结果为格式化后的时间 年-月-日 时:分:秒
​		print(struct_time)						#结果为可定义元组
​		print(struct_time.tm_year)				#结果为计算机当前年份
        ☆ datetime：显示当前系统日期
​		import datetime
​		date = datetime.datetime.now()
​		返回值为0-6,0为星期一、6为星期日
​	4. math
   	        import math
   		math.ceil(3.4)		#大于3.4的最小整数，结果为4
   		math.floor(3.4)		#小于3.4的最大整数，结果为4
  		math.fabs(-3)		#绝对值，结果3
  		math.e			#2.71828
   		math.pi			#3.14159
​	5. random
   		import random
   		random.random()		#生成一个0-1的随机浮点数
   		random.randint(1,100)	#随机生成一个1-100的整数
   		random.randrange(1,101,2)	#随机生成一个1-100间的偶数

​* os模块是与操作系统交互的接口
        import os
​	1. os.getcwd()	#获取当前工作目录，即当前python脚本工作的目录路径
​	2. os.chdir("dirname")	#改变当前脚本工作目录，相当于shell下的cd
​	3. os.curdir	#返回当前目录
​	4. os.pardir	#获取当前目录的父目录字符串
​	5. os.mkdir("dirname")	#生成单极目录
​	6. os.rmdir("dirname")	#删除单级空目录
​	7. os.makedirs("dirname1/dirname2")	#生成多级目录
​	8. os.removedir("dirname")	#删除多级空目录
​	9. os.remove()	#删除一个文件
​	10. os.listdir("dirname")	#列出指定目录下的所有目录包括子目录和隐藏目录
​	11. os.rename("oldname","newname")	#重命名文件/文件夹
​	12. os.path.abspath(path)	#返回规范化的绝对路径
​	13. os.path.exists(path)	#判断路径是否存在
​	14. os.path.getatime(path)	#返回path所指向的文件或者目录的最后访问时间
​	15. os.path.getmtime(path)	#返回path所指向的文件或者目录的最后修改时间

* platform
​	import platform
​	print(platform.platform())		#打印当前操作系统名称及版本号
​	platform.system()		#获取操作系统类型
​	platform.version()		#获取当前操系统的版本信息
​	platform.machine()		#获取当前计算机类型的信息
​	platform.uname()			#获取计算机综合信息
​	platform.python_version()		#获取python版本号

​* sys模块是与python解释器交互的接口
        import sys
​	1. sys.argv		#命令行参数list，第一个元素是程序本身路径（只能在终端执行）
​	2. sys.exit(n)	#退出程序。正常退出时sys.exit(0)，错误退出时sys.exit(1)
​	3. sys.version	#获取python解释程序的版本信息
​	4. sys.path		#返回模块搜索路径
​	5. sys.platform	#返回操作系统平台名称
        6. sys.getdefaultencoding()	#获取系统当前编码

14. 序列化模块

1. 从数据类型 ——> 字符串的过程    就是序列化
​2. 从字符串 ——> 数据类型的过程		就是反序列化
​* json	*****
​* pickle	****
​* shelve	***

​json:
​	* 通用的序列化格式(优点)
​	* 只有很少一部分数据类型能够通过json转化成字符串(缺点)
​pickle：
​	* 所有的python中的数据类型都可以转化成字符串形式(优点)
​	* pickle序列化的内容只有python能够理解(缺点)
​	* 反序列化依赖python代码(缺点)
​shelve
​	* 序列化句柄
​	* 使用句柄直接操作，非常 方便
json	dumps序列化方法	loads反序列化方法
​	import json
​	dic = {"k":"v"}
​	str_d = json.dumps(dic)
​	print(type(str_d),str_d)	#序列化结果<class 'str'> {"k","v"}

15. 异常处理

​ 1. try: ...... except 异常类型: ......(最后可跟一个 except Exception as e: ......) finally: ......

    try:
      i = 10
      print(30/(i - 10))
    except Exception as e:
      print(e)
    finally:
      print("执行完成")

16. 反射

​ 1. 把字符串当成变量名、函数名来使用

17. 常用模块

​ 1. hashlib模块
​ 2. configparser模块

Python制图

• 导入 turtle 模块
  • import turtle
  • turtle.showturtle() 显示箭头
  • turtle.write("123") 写字符串
  • turtle.forward(300) 前进300像素
  • turtle.color("red") 改变箭头颜色
  • turtle.left(90) 箭头左转90度
  • turtle.goto(0,50) 去坐标(0,50)
  • turtle.penup() 抬笔
  • turtle.pendown() 下笔
  • turtle.circle(100) 画圆，半径为100像素