目录
0.背景
如果你熟悉java 或其他面向对象语言，快速看下面这些代码快速入门python
1.基础
print("hello world")
# 这是一行注释
#变量
age = 20
#字符串
name = 'bobe'
#字符串格式化
print("name is {0} , age is {1}".format(name,age)) #Python 从 0 开始计数，这意味着索引中的第一位是 0，第二位是 1，以此类推。
print("name is {} , age is {}".format(name,age)) # 不写序号也行，format 方法所做的事情便是将每个参数值替换至格式所在的位置
#联立字符串
print("name is " + name + ", age is " + str(age))
#对浮点数保留小数点后3位
print("{0:.3f}".format(1.0 / 3))
#使用符号填充文本
print("{0:_^10}".format("hello")) # 使用了下划线填充文本，文本居中
#基于关键词输出
print("{name} wrote {book}".format(name = "aaa",book = "bbb")) # format 的时候将 name 和 book 格式化了
#关于print 的自动换行，print 总是会以一个不可见的“新一行”字符（\n ）结尾，因此重复调用 print 将会在相互独立的一行中分别打印。为防止打印过程中出现这一换行符，你可以通过 end 指定其应以空白结尾：
print("a",end="")
print("b",end="")
print("c") # 这样打印出来的结果就不换行了
# 转义
print('what\'s')
print('你好\\ 哈哈')
#原始字符串
#如果你需要指定一些未经过特殊处理的字符串，比如转义序列，那么你需要在字符串前增加r 或 R 来指定一个 原始（ Raw） 字符串
print(r"sssaa d\ad asadsa\dsadas'dsa'ssdsa#")
#变量
i = 1
print("i=" + str(i)) #str(1) 将 i 转换成字符串
i = i + 2
print("i=" + str(i))
s = '''dsadasdd""sdadsad"'sdsdsd''' # ''' 三引号里面的字符串将原样输出
print(s)
print("我是一物理行代码")#物理行
print("这是一物理行");print("这是另一物理行") # 这是一逻辑行
#Python 鼓励每一行使用一句独立语句从而使得代码更加可读。
#显式行连接
s = 'This is a string. \
This continues the string.'
print(s) #如果你有一行非常长的代码，你可以通过使用反斜杠将其拆分成多个物理行。这被称作显式行连接
2.运算符与表达式
print("运算符")
a = 3
b = 5
c = 1
d = True
e = False
print("加："+str(a + b))
print("减："+str(a - b))
print("乘：" + str(a * b))
print("除："+str(a / b))
print("乘方："+str(a ** b))#意为 a的b次方
print("整除："+str(a // c))
print("取模："+str(b % a))#返回除法运算后的余数
print("左移：" + str(a << c ))#左移， 每个数字在内存中以二进制数表示，即 0 和1
print("右移：" + str(a >> c))#右移
print("按位与 ："+ str(a & c))#
print("按位或 ："+ str(a | c))#
print("按位异或 ："+ str(a ^ c))
print("按位取反："+ str(~a))
print("小于："+ str(a < b))
print("大于："+ str(a > b))
print("大于等于："+ str(a >= b))
print("小于等于："+ str(a <= b))
print("是否等于："+ str(a == b))
print("不等于："+ str(a != b))
print("not非："+ str(not d))
print("and和："+ str(d and e))
print("or或："+ str(d or e))
print("表达式")
i = 5
print("i = " + str(i))
i = i + 5
i += 3
print("i = " + str(i))
3.控制流
print('控制流')
print("if")
num = 16
#输入数字
#inputNum = int(input("请输入任意数字:"))
inputNum = 5
print("你输入了：" + str(inputNum))
if num == inputNum: # 这里需要一个冒号
print("num == inputNum")
elif num < inputNum:
print('num < imputNum')
else:
print('num > inputNum')
print("比较结束")
#Python 中不存在 switch 语句
#while循环
#while 语句同样可以拥有 else 子句作为可选选项
a= 10
b = True
while b:
a = a -1
print("a = :" + str(a))
if a <= 0:
b = False
else:
print(str(b))
print("循环结束")
#for循环
for c in range(1,5):
print("c:" + str(c))
else:
print("for 循环结束")
#下面是多行注释的写法
'''
range 将会返回一个数字序列，从第一个数字
开始，至第二个数字结束。举个例子， range(1,5) 将输出序列 [1, 2, 3, 4] 。在默认情况
下， range 将会以 1 逐步递增。如果我们向 range 提供第三个数字，则这个数字将成为逐
步递增的加数。同样举个例子来说明， range(1,5,2) 将会输出 [1, 3] 。要记住这一序列扩
展直到第二个数字，也就是说，它不会包括第二个数字在内
'''
#break 语句 ，用于终止循环体
d = 1
while d < 10:
print("d:" + str(d))
d = d + 1
if d > 5:
break
print("循环结束了d:" + str(d))
#continue 语句， 用于跳过当次循环，开始下次循环
e = 2
while e < 5:
e+=1
if e == 3 :
continue
print("e= " + str(e))
print("循环结束了：" + str(e))
4. 函数
print("函数")
"""
函数可以通过关键字 def 来定义。这一关键字后跟一个函数的标识符名称，再跟一对圆括
号，其中可以包括一些变量的名称，再以冒号结尾，结束这一行。随后而来的语句块是函数
的一部分。
"""
def sayHello():
# 这里属于函数体内容
print("sayHello函数被调用了")
# 函数结束
# 调用3次函数
sayHello()
sayHello()
sayHello()
print("带参数的函数")
def comple(a, b):
if a > b:
print("a > b")
elif a == b:
print("a == b")
else:
print("a < b")
# 函数要定义在调用前面， 否则会报错
comple(3, 5)
print("局部变量")
x = 50
def fun1(a):
print("函数内 x is:" + str(a))
x = 3;
print("changed x is : " + str(x))
fun1(x)
print("函数外：" + str(x))
print("global 语句")
y = 30
def fun2():
global y
print("y is:" + str(y))
y = 15
print("changed y :" + str(y))
fun2()
print(" out y :" + str(y))
"""
global 语句用以声明 x 是一个全局变量——因此，当我们在函数中为 x 进行赋值时，这
一改动将影响到我们在主代码块中使用的 x 的值。
可以在同一句 global 语句中指定不止一个的全局变量，例如 global x, y, z
"""
print("默认参数值")
def fun3(a, b=5):
print(str(a * b))
fun3(2) # 调用函数，参数不给值时，会使用定义函数时的默认值
fun3(2, 3)
"""
只有那些位于参数列表末尾的参数才能被赋予默认参数值，意即在函数的参数列表中拥
有默认参数值的参数不能位于没有默认参数值的参数之前。
这是因为值是按参数所处的位置依次分配的。举例来说， def func(a, b=5) 是有效的，
但 def func(a=5, b) 是无效的
"""
print("关键字参数")
"""
如果你有一些具有许多参数的函数，而你又希望只对其中的一些进行指定，那么你可以通过
命名它们来给这些参数赋值——这就是关键字参数（ Keyword Arguments） ——我们使用命
名（ 关键字） 而非位置（ 一直以来我们所使用的方式） 来指定函数中的参数。
这样做有两大优点——其一，我们不再需要考虑参数的顺序，函数的使用将更加容易。其
二，我们可以只对那些我们希望赋予的参数以赋值，只要其它的参数都具有默认参数值。
"""
def fun4(a, b=3, c=5):
print("a = ", a, " b:=", b, ' c:=', c)
fun4(1, 2, 3)
fun4(1, 3)
fun4(1, c=10)
fun4(a=1, b=1, c=1)
"""
print("可变参数")
def fun5(a=5, *num, **list):
print('a', a)
for z in num:
print("z", z)
for c, d in list:
print(c, d)
fun5(3)
fun5(10, 1, 2, 4, Jack=1123, John=2231, Inge=1560)
"""
print("return 语句")
# return 语句用于从函数中返回，也就是中断函数。我们也可以选择在中断函数时从函数中返回一个值。
def testReturn(x, y):
if x > y:
return x
elif x == y:
return "相等"
else:
return None
print(testReturn(3,5))
print(testReturn(3,3))
print(testReturn(5,3))
"""
要注意到如果 return 语句没有搭配任何一个值则代表着 返回 None 。 None 在 Python 中一
个特殊的类型，代表着虚无。举个例子， 它用于指示一个变量没有值，如果有值则它的值便
是 None（ 虚无） 。
每一个函数都在其末尾隐含了一句 return None ，除非你写了你自己的 return 语句。
"""
print("DocStrings文档字符串（ Documentation Strings） ")
def doc(x,y):
"""打印两参数最大的数
:param x: x
:param y: y
:return: 较大的数
"""
if x > y:
print(x)
else:
print(y)
doc(3,5)
print(doc.__doc__)
#python 中，所有的东西都是对象，所以函数也是对象， 调用函数的 __doc__ 方法， 会打印函数内部写的DocStrings文档字符串
5.模块
test
if __name__ == '__main__':
print("a当前程序运行在自己的模块中")
else:
print("a当前模块被加载在另一个模块中运行")
def sayhello():
print("hahha ,我 是 子 模块 ")
import sys
print("模块")
for i in sys.argv:
print(i)
print(sys.path)
#每一个 Python 模块都定义了它的 __name__ 属性。如果它与 __main__ 属性相同则代表这一模块是由用户独立运行的
if __name__ == '__main__':
print("当前程序运行在自己的模块中")
else:
print("当前模块被加载在另一个模块中运行")
#导入测试模块
import hello_05_test
hello_05_test.sayhello()
#dir 函数
l = dir()
print(l)
dir1 = dir(hello_05_test)
print(dir1)
a= 3
print(a)
del a # 删除对a的定义
# print("a："+ str(a)) #NameError: name 'a' is not defined
c = 3
print(dir(c))
6.数据结构
print('数据结构')
# 列表（可变的）
mList = ['a', 'b', 'c']
print(mList)
for i in mList:
print(i)
mList.append('d') # 追加
print(mList)
for i in mList:
print(i)
mList.append('z')
mList.append('f')
mList.sort() # 排序
print(mList)
s = mList[0]
print(s)
del mList[0] # 移除
print(mList)
# 元组
print("元组（不可变）元组内的数值永远不会变")
names = ("bob", 'cat', 'care')
print(names)
print("获取长度")
print(len(names))
temp = ('a', 'b', names, 3)
print(temp)
# 字典(类似java中的map)
print("字典")
desc = {"a": "aaa", "b": "bbb", "c": "ccc"}
print(desc)
# 删除一对键值
del desc["a"]
print(desc)
for k, v in desc.items():
print(k, v)
# 增加一元素
desc["e"] = "eee"
print(desc)
if "e" in desc:
print(desc["e"])
# 序列
print("序列")
shoplist = ['apple', 'mango', 'carrot', 'banana']
name = 'swaroop'
# 索引或“下标（ Subscription） ”操作符 #
print('Item 0 is', shoplist[0])
print('Item 1 is', shoplist[1])
print('Item 2 is', shoplist[2])
print('Item 3 is', shoplist[3])
print('Item -1 is', shoplist[-1])
print('Item -2 is', shoplist[-2])
print('Character 0 is', name[0])
# Slicing on a list #
print('Item 1 to 3 is', shoplist[1:3])
print('Item 2 to end is', shoplist[2:])
print('Item 1 to -1 is', shoplist[1:-1])
print('Item start to end is', shoplist[:])
# 从某一字符串中切片 #
print('characters 1 to 3 is', name[1:3])
print('characters 2 to end is', name[2:])
print('characters 1 to -1 is', name[1:-1])
print('characters start to end is', name[:])
#集合
print("集合")
shoplist2 = ['apple', 'mango', 'carrot', 'banana']
print(shoplist2)
mshl = shoplist2
print(mshl)
del mshl[0]
print(shoplist2)
print(mshl)
7. 面向对象
print("面向对象")
class Person:
desc = "我是一个人" #类字段
#初始化函数。类似java 的构造函数
def __init__(self,name):
self.name = name #成员字段
#成员方法
def say(self):
print("my name is :",self.name)
#类方法， 静态方法
@classmethod
def printDesc(cls):
print(cls.desc)
p = Person("小明")
p.say()
Person.printDesc()
继承
#定义学校工作者类
class SchoolMember:
#初始化函数
def __init__(self, name, age):
self.name = name
self.age = age
def print(self):
print("name :{0} age:{1} ".format(self.name, self.age))
#定义学生类
class Student(SchoolMember):#继承写法
def __init__(self, name, age, score):
#需要主动调用父类的初始化方法， python不会主动调用
SchoolMember.__init__(self, name, age)
self.score = score
def printScore(self):
print("student score:",self.score)
class Teacher(SchoolMember):
def __init__(self,name,age,salary):
SchoolMember.__init__(self,name,age)
self.salary = salary
def print(self):
print("teacher name{0} , age{1} , salary{2}".format(self.name,self.age,self.salary))
s = SchoolMember("小明", 13)
s.print()
student = Student("",18,90)
student.printScore()
t = Teacher("老王",39,5000)
t.print()
8.文件
#定义学校工作者类
class SchoolMember:
#初始化函数
def __init__(self, name, age):
self.name = name
self.age = age
def print(self):
print("name :{0} age:{1} ".format(self.name, self.age))
#定义学生类
class Student(SchoolMember):#继承写法
def __init__(self, name, age, score):
#需要主动调用父类的初始化方法， python不会主动调用
SchoolMember.__init__(self, name, age)
self.score = score
def printScore(self):
print("student score:",self.score)
class Teacher(SchoolMember):
def __init__(self,name,age,salary):
SchoolMember.__init__(self,name,age)
self.salary = salary
def print(self):
print("teacher name{0} , age{1} , salary{2}".format(self.name,self.age,self.salary))
s = SchoolMember("小明", 13)
s.print()
student = Student("",18,90)
student.printScore()
t = Teacher("老王",39,5000)
t.print()
9.异常
print("异常")
# 异常捕获
try:
i = 4 / 0
except ZeroDivisionError as e:
print("error", e.args)
try:
i = 4 / 0
except ZeroDivisionError: # 也可以不写具体原因当参数
print("error")
print("抛出异常")
def say():
print("下面会开始抛出异常")
raise Exception("我是被抛出的异常") # 此处用raise 关键字抛出异常
try:
say()
except Exception as e:
print(e.args)
print("自定义异常")
class MyError(Exception):
def __init__(self, error):
self.error = error
print("下面抛出一自定义异常")
try:
raise MyError("这是一个自定义抛出的异常")
except MyError as e:
print(e.error)
pass
import sys
import time
f = None
try:
f = open("poem.txt")
# 我们常用的文件阅读风格
while True:
line = f.readline()
if len(line) == 0:
break
print(line, end='')
sys.stdout.flush()
print("Press ctrl+c now")
# 为了确保它能运行一段时间
time.sleep(2)
except IOError:
print("Could not find file poem.txt")
except KeyboardInterrupt:
print("!! You cancelled the reading from the file.")
finally:
if f:
f.close()
print("(Cleaning up: Closed the file)")
10.with语句
"""
在 try 块中获取资源，然后在 finally 块中释放资源是一种常见的模式。因此，还有一个
with 语句使得这一过程可以以一种干净的姿态得以完成
"""
with open("test.txt") as f:
for line in f:
print(line)
"""
程序输出的内容应与上一个案例所呈现的相同。本例的不同之处在于我们使用的是 open 函
数与 with 语句——我们将关闭文件的操作交由 with open 来自动完成。
在幕后发生的事情是有一项 with 语句所使用的协议（ Protocol） 。它会获取由 open 语句
返回的对象，在本案例中就是“thefile”。
它总会在代码块开始之前调用 thefile.__enter__ 函数，并且总会在代码块执行完毕之后调
用 thefile.__exit__ 。
因此，我们在 finally 代码块中编写的代码应该格外留心 __exit__ 方法的自动操作。这能
够帮助我们避免重复显式使用 try..finally 语句。
"""
11.标准库
import sys
print(sys.version_info)
import os
import platform
import logging
if platform.platform().startswith("Windows"):
logging_file = os.path.join(os.getenv('HOMEDRIVE'),
os.getenv('HOMEPATH'),
'test.log')
else:
logging_file = os.path.join(os.getenv('HOME'),
'test.log')
print("Logging to", logging_file)
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s : %(levelname)s : %(message)s',
filename=logging_file,
filemode='w',
)
logging.debug("aaa")
logging.info("bbb")
logging.warning("ccc")
231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
