- 第一个字符必须是字母表中字母或下划线 _ 。
- 标识符的其他的部分由字母、数字和下划线组成。
- 标识符对大小写敏感。
保留字即关键字，不能用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：
import keyword
res = keyword.kwlist
print(res)
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']# 1.注释
print ("Hello, Python!") # 注释
'''
2.注释
'''
"""
3.注释
"""- int
- float
- bool
- complex 复数
a = 1
b = 1.1
c = True
print(type(a))
print(type(b))
print(type(c))
'''
<class 'int'>
<class 'float'>
<class 'bool'>
'''使用 '' 或 ''''
a = '单引号'
b = "双引号"
print(type(a))
print(type(b))
'''
<class 'str'>
<class 'str'>
'''
'''
索引
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
P y t h o n
'''
str = 'Python'
print(str) # 输出字符串 Python
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 Pytho
print(str[0]) # 输出字符串第一个字符 P
print(str[2:5]) # 输出从第三个开始到第五个的字符 tho
print(str[2:]) # 输出从第三个开始的后的所有字符 thon
print(str * 2) # 输出字符串两次，也可以写成 print (2 * str) PythonPython
print(str + "Java") # 连接字符串 PythonJava
# 原始字符串
print(r'Java\nC') # Java\nC
# 格式化
print ("书籍：%s 价格：%d " % ('Python', 29))
# Python 3.6
name = 'Python'
print(f'Hello {name}')l1 = ['A', 1, 1.2, True]
l2 = ['B', 33]
print(l1) # 输出完整列表 ['A', 1, 1.2, True]
print(l1[0]) # 输出列表第一个元素 A
print(l1[1:3]) # 从第二个开始输出到第三个元素 切片 [1, 1.2]
print(l1[2:]) # 输出从第三个元素开始的所有元素 [1.2, True]
print(l2 * 2) # 输出两次列表 ['B', 33, 'B', 33]
print(l1 + l2) # 连接列表 ['A', 1, 1.2, True, 'B', 33]
l1[2:4] = [] # 将对应的元素值设置为 []
print(l1) # ['A', 1]
l3 = ['A', 'B', 'C', 'D', 'E']
print(l3[::2]) # 设置步长 ['A', 'C', 'E']
print(l3[::-2]) # 负数后往前 ['E', 'C', 'A']
print(l3[1:4:2]) # ['B', 'D']
l1 = ['A', 'B', 'C', 'D']
len(l1) # 列表元素个数
max(l1) # 列表元素最大值
min(l1) # 列表元素最小值
t1 = ('1', '2')
l2 = list(t1) # 将元组或字符串转换为列表
l3 = list('Hello')
l1.append('D') # 列表末尾添加新的对象
l1.count('D') # 统计某个元素在列表中出现的次数
l3=list(range(5))
l1.extend(l3) # 列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
l1.index('D') # 从列表中找出某个值第一个匹配项的索引位置
l1.insert(0, 'B++') # 指定对象插入列表的指定位置
l1.pop() # 移除列表中的一个元素（默认最后一个元素）
l1.pop(-2) # index 索引值
l1.remove('B++') # 移除列表中某个值的第一个匹配项
l1.reverse() # 反向列表中元素
l1.sort() # 原列表进行排序
l1.clear() # 清空列表
l3 = l1.copy() # 复制列表
l7 = ['A', 'B', 'C', 'D', 'E']
for v in l7: # 遍历
print(v, end=' ')
for i, v in enumerate(l7): # enumerate() 获取 index、value
print("下标=%s 值=%s" % (i, v))Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ()，列表使用方括号 [],。
操作和 list 差不多
t1 = ('A', 'B', 'C', 'D', 'E')
for i, v in enumerate(t1):
print("下标=%s 值=%s" % (i, v))
t2 = (1, 2)
t3 = ("A", "B")
print(t2 + t3) # (1, 2, 'A', 'B') 集合（set）是一个无序的不重复元素序列。
括号 { } 或者 set() 函数创建集合。
a = set('abracadabra')
print(a) # {'a', 'r', 'b', 'c', 'd'}
b = set(("A", "B", "C"))
b.add('E') # 添加
b.update({1,3}) # 添加多个
b.remove('A') # 移除
len(b) # 计算集合元素个数
b.clear() # 清空字典是另一种可变容器模型，且可存储任意类型对象。类似与 Java 中的 Map。
不允许同一个键出现两次。创建时如果同一个键被赋值两次，会覆盖。
d1 = {'name': 'Java', 'price': 76}
print(d1['name'], d1['price'])
d1['name'] = 'Python' # 修改
print(d1)
d1['des'] = '不会写' # 增加
print(d1)
del d1['des'] # 删除
print(d1)
d2 = {'name': 'Java', 'price': 76}
for k, v in d2.items(): # 遍历
print("key=%s value=%s" % (k, v))
"""
key=name value=Java
key=price value=76
""" # if...elif..esle if...else
x = 1
if x == 1:
print('A')
elif x == 2
print('B')
else
print('C')# while
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和为: %d" % (n,sum))
# while...else 在 while … else 在条件语句为 false 时执行 else 的语句块。
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
# for
languages = ["C", "C++", "Python"]
for x in languages
print(x)pass 不做任何事情，一般用做占位语句。
x = 1
if x == 1:
pass迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
- iter()
- next()
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")
# 循环
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))
except StopIteration: # 异常用于标识迭代的完成
sys.exit() 使用了 yield 的函数被称为生成器（generator），生成器是一个返回迭代器的函数，只能用于迭代操作。
import sys
def fibonacci(n,w=0): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
print('%d,%d' % (a,b))
counter += 1
f = fibonacci(10,0) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except :
sys.exit()
def max(a,b)
if a > b:
return a
else:
return b
# 默认参数
def printInfo(name,age = 34)
print(name,age)
return
printInfo("张三")
# 不定长参数
def printInfo( arg1, *vartuple ):
print("输出: ")
print(arg1)
print(vartuple) # 参数会以元组(tuple)的形式导
printinfo( 70, 60, 50 )
# **参数会以字典的形式导入
def printInfo( arg1, **vartuple ):
# 匿名函数
sum = lambda arg1, arg2: arg1 + arg2
print("相加后的值为 : ", sum( 10, 20 ))# support.py
def print_func(par):
print ("Hello : ", par)
return
# main.py
# 导入模块
import support
support.print_func("Runoob")
# from … import 语句
# Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中
from fibo import fib, fib2
# from … import *， 把一个模块的所有内容全都导入到当前的命名空间- print()：打印
- str()： 函数返回一个用户易读的表达形式
- repr()：产生一个解释器易读的表达形式
- str.format() ：
- print('{}'.format('Python'))
- print('{name}'.format(name = 'Python'))
- print('{0}，{1}'.format('Python','Java'))
# open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。记得调用 close() 方法
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)- file: 必需，文件路径（相对或者绝对路径）。
- mode: 可选，文件打开模式
- buffering: 设置缓冲
- encoding: 一般使用utf8
- errors: 报错级别
- newline: 区分换行符
- closefd: 传入的file参数类型
- opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
Python 有两种错误很容易辨认：语法错误和异常。
# 异常处理
# try/except
while True:
try:
x = int(input("请输入一个数字: "))
break
except ValueError:
print("您输入的不是数字，请再次尝试输入！")
# try/except...else
try:
... # 执行代码
except ...: # 发生异常时执行的代码
...
else: # 没有异常时执行的代码
...
finally: # 都会执行
# raise 抛出异常
x = 10
if x > 5:
raise Exception('x 不能大于 5。x 的值为: {}'.format(x))class MyClass:
i = 12
name = ""
price = 0
__age = 0 # 私有方法
def f(self):
return 'Hello World'
# def __init__(self): # 默认构造方法
def __init__(self,name,price): # 构造方法
self.name = name
self.price = price
# x = MyClass()
x = MyClass('张三',34)
# 继承
class People:
name = ''
age = 0
def __init__(self,name,age)
self.name = name
self.age = age
def speak(self):
print('Hello')
class Student(Person): # 继承 class Student(Person,Speaker) # 多继承
def speak(self):
print('覆写父类的方法')简单例子
class Person:
# 1.公有变量
name = ''
age = 0
# 2.私有变量
__weight = 0.0
# 3.构造函数
def __init__(self, name, age, weight):
self.name = name
self.age = age
self.__weight = weight
# 4.自定义方法
def learn(self, course):
print("%s 学习 %s" % (self.name, course))
# 5.私有方法
def __sleep(self):
print("%s sleep" % self.name)
class Speaker:
topic = ''
time = 0
def __init__(self, topic):
self.topic = topic
# 6.重载，可以使用默认 say() say(time = 0) say(time = '40',info = 'Java 学习')
def say(self, time=0, info=''):
print("%s 演讲时间 %d 分" % (info, time))
# 7.继承
class Student(Person):
def __init__(self, name, age, weight):
super().__init__(name, age, weight)
# 8.方法重写
def learn(self, course):
# 9.调用父类方法
super(course)
print("%s 已经不学习 %s" % (self.name, course))
# 9.多继承:Person,Speaker
class Doctor(Person, Speaker):
def __init__(self, name, age, weight, topic):
Person.__init__(self, name, age, weight)
Speaker.__init__(self, topic)
# 静态方法: 用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。
# 普通方法: 默认有个self参数，且只能被对象调用。
# 类方法: 默认有个 cls 参数，可以被类和对象调用，需要加上 @classmethod 装饰器。
class Teacher:
@staticmethod
def a():
print('静态方法')
@classmethod
def b(cls):
print('类方法')
def c(self):
print('类方法')
if __name__ == '__main__':
speaker = Speaker("Java 编程")
speaker.say(40, "如何学习 Java")
speaker.say(info="如何不学习 Java")
student = Student()
student.learn("Python")
print(speaker.topic)
doctor = Doctor("张三", 40, 25, "Python 学习")命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。作用，避免名字冲突的一种方法
变量查找顺序：当前域 -> 外部域(如果有) -> 全局域 -> 内置域。
# 当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
# 修改全局变量 num
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
print(num)
# 要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()