Python基础-01
1.1 注释
注: 以下示例代码均以python3为主,若有python2代码 会说明
单行注释: 以#开头，#右边的所有东西当做说明
#我是注释，可以在里写一些功能说明之类的哦
print('hello world')多行注释:
'''
我是一个
多行注释
额额额额
'''
print("这个就是多行注释！")
但是如果你用的是python2，注意要让程序支持中文:
要加上#coding=utf-8，且=号两边不能有空格
#coding=utf-8
#我是phython2
print 'python2版本'1.2 变量及类型
标准数据类型
Python3中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元祖）
Set（集合）
Dictionary（字典）
**不可变数据（3个）: **Number（数字）、String（字符串）、Tuple（元组）;
可变数据（3个）: List（列表）、Dictionary（字典）、Set（集合）。
1.2.1Number（数字）
Python3 支持 int 、float、bool、complex（复数）。
Python3 中,只有一种整数类型 int , 表示为长整型, 没有python2 中的 Long。
内置的 type() 函数可以用来查询变量所指的对象类型
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>此外还可以用 isinstance 来判断：
>>>a = 111
>>> isinstance(a, int)
True
>>>其中 isinstance 和 type 的区别在于:
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False区别就是:
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
当你指定一个值时, Number 对象就会被创建:
var1 = 1
var2 = 10您也可以使用 del 语句删除一些对象引用。例如:
del var
del var_a, var_b数值运算:
>>>5 + 4 # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7 # 乘法
21
>>> 2 / 4 # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
321.2.2 String（字符串）
Python中的字符串用单引号 ’ 或者 ” 括起来，同时使用 \ 转义特殊字符。
同时，加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。
字符串输出：
#Python3
>>>a="中国"
>>>b=2
>>>print("我很%d,但是我爱%s"%(b,a),end="")
>>>print(" -署名Jack")
我很2,但是我爱中国 -署名Jack
#Python2
>>>#coding=utf-8
>>>a="中国"
>>>b=2
>>>print"我很%d,但是我爱%s"%(b,a),
>>>print" -署名Jack"
我很2,但是我爱中国 -署名Jack注意：常用 %d格式化整数，%s格式化字符串,不换行打印加上 end=”” （python3）， 如果为python2 如上 加上 ，即可
字符串输入 :
input 能够帮你完成从键盘中获取数据，然后保存到指定的变量中
注意: input获取的数据，都是以字符串的形式进行保存，即使输入的是数字，那么也是以字符串的形式进行保存
#Python3
>>>username = input("请输入用户名：")
>>>print("当前的用户名为:%s"%username)
#Python2
>>>#coding=utf-8
>>>username = raw_input("请输入您的用户名：")
>>>print "您的用户名为:%s"%username
字符串的下标与切片：
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作
切片的语法: [起始：结束：步长]
选取的区间属于左闭右开型，即从“起始”位开始，到 “结束” 位的前一位结束 （不包括结束位本身）
>>> a = "abcdef"
>>> a[:3]
'abc'
>>> a[::2]
'ace'
>>> a[5:1:2]
''
>>> a[1:5:2]
'bd'
>>> a[::-2]
'fdb'
>>> a[5:1:-2]
'fd'字符串的常见操作：
<1> find
检测str是否包含在mystr中，如果是返回开始的索引值，否则返回 -1
用法：
mystr.find(str, start=0, end=len(mystr))示例：
mystr='hello world Jack and JackSmith'
num = mystr.find('Jack')
print(num)
>>> 12
mystr='hello world Jack and JackSmith'
num = mystr.find('Jack',0,10)
print(num)
>>> -1<2> index
跟 find() 方法一样, 只不过如果str不在mystr中会报一个异常
用法：
mystr.index(str, start=0, end=len(mystr))示例：
mystr='hello world Jack and JackSmith'
num = mystr.index('Jack')
print(num)
>>> 12
mystr='hello world Jack and JackSmith'
num = mystr.index('Jack',0,10)
print(num)
>>> Traceback (most recent call last):
File "pythonFile.txt", line 2, in <module>
num = mystr.index('Jack',0,10)
ValueError: substring not found
<3> count
返回str在 start和end之间 在mystr里面出现的次数
用法：
mystr.count(str, start=0, end=len(mystr))示例：
mystr='hello world Jack and JackSmith'
num = mystr.count('Jack')
print(num)
>>> 2<4> replace
把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
用法：
mystr.replace(str1, str2, mystr.count(str1))示例：
name='helloworld ha ha'
newName = name.replace('ha','HA',1)
print("name=%s"%name)
print("newName=%s"%newName)
>>> name=helloworld ha ha
>>> newName=helloworld HA ha
<5> split
以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
用法：
mystr.split(str=" ", 2)示例：
name='hello world ha ha'
newName1 = name.split(" ")
print(newName1)
newName2 = name.split(" ",2)
print(newName2)
>>> ['hello', 'world', 'ha', 'ha']
>>> ['hello', 'world', 'ha ha']
<6> capitalize
把字符串的第一个字符大写
用法：
mystr.capitalize()示例：
mystr='hello world jack and bao'
newStr = mystr.capitalize()
print (newStr)
>>> Hello world jack and bao<7> startswith
检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False
用法：
mystr.startswith(obj)示例：
1.4 函数
用法：
def 函数名():
代码示例：
#定义函数
def printInfo():
print('--------------')
print('人生苦短 我用python')
print('--------------')
#调用函数
printInfo()
>>> --------------
>>> 人生苦短 我用python
>>> --------------
1.4.1 函数的文档说明
def calculate(a,b):
"该函数用来完成对两个数进行求和"
print("a+b=%d"%(a+b))
calculate(1,2)
>>> a+b=3
help(calculate)
>>> Help on function calculate in module __main__:
>>> calculate(a, b)
>>> 该函数用来完成对两个数进行求和
(END) 调用函数时，参数的顺序：
def addSum(a,b):
print("a(%s)+b(%s)的和等于%d"%(a,b,a+b))
addSum(2,3)
>>> a(2)+b(3)的和等于5
def addSum(a,b):
print("a(%s)+b(%s)的和等于%d"%(a,b,a+b))
addSum(b=3,a=2)
>>> a(2)+b(3)的和等于51.4.2 函数的返回值
在python 中我们可不可以返回多个值？
def divide(a,b):
shang=a//b
yushu=a%b
return shang,yushu
sh,yu=divide(9,2)
print("a除b的商:%s,余数:%s"%(sh,yu))
>> a除b的商:4,余数:1本质上利用了元组
1.4.3 局部变量和全局变量
如果在函数中修改全局变量，那么就需要使用 global 进行声明，否则出错
如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的
对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量
对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量
python中交换 2个 变量的几种方式：
a=4
b=5
#第一种
c=a
a=b
b=c
#第二种
a=a+b
b=a-b
a=a-b
#第三种
a,b=b,a
其他知识点扩充：
# 1
a=[100]
def test(num):
num+=num
print(num)
test(a)
print(a)
>>> [100, 100]
>>> [100, 100]
# 2
a=[100]
def test(num):
num=num+num
print(num)
test(a)
print(a)
>>> [100, 100]
>>> [100]
1.4.4 函数参数
<1> 缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入
def printinfo( name, age = 35 ):
# 打印任何传入的字符串
print "Name: ", name
print "Age ", age
# 调用printinfo函数
printinfo(name="miki" )
printinfo( age=9,name="miki" )
>>> Name: miki
>>> Age 35
>>> Name: miki
>>> Age 9注意：带有默认值的参数一定要位于参数列表的后面
>>> def printinfo(name, age=35, sex):
... print name
...
File "<stdin>", line 1
SyntaxError: non-default argument follows default argument<2> 不定长参数
加了星号（）的变量args会存放所有未命名的变量参数，args为元组；而加*的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。
def test(a,b,c=33,*args,**kwargs):
print(a)
print(b)
print(c)
print(args)
print(kwargs)
test(1,2,44,55,name='张三',age=19)
>> 1
>> 2
>> 44
>> (55,)
>> {'name': '张三', 'age': 19}
注意：若元组只有单个元素，要在此单个元素后加个，表区分 是个元组，否则python解释器会把其当成一个算数表达式
<3> 拆包
若实参中 使用 * 表示拆元组,使用 ** 表示拆字典
def test(a,b,c=33,*args,**kwargs):
print(a)
print(b)
print(c)
print(args)
print(kwargs)
#test(1,2,44,55,name='张三',age=19)
A=(44,55,66)
B={'name':'张三','age':19}
test(1,2,3,*A,**B)
>> 1
>> 2
>> 3
>> (44, 55, 66)
>> {'name': '张三', 'age': 19}1.4.5 匿名函数
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
案例：排序
infos=[{'name':'Jack','age':19},{'name':'Smith','age':20},{'name':'David','age':25}]
infos.sort()
print(infos)
#直接排序会报错 因为解释器无法判别 是按名称还是年龄排序 所以接下来需要进行指定
>>> Traceback (most recent call last):
>>> File "01-test.py", line 2, in <module>
>>> infos.sort()
>>> TypeError: '<' not supported between instances of 'dict' and 'dict'使用lambda进行指定，排序规则
infos=[{'name':'Jack','age':19},{'name':'Smith','age':20},{'name':'David','age':25}]
infos.sort(key=lambda x:x['name'])
print(infos)
>>> [{'name': 'David', 'age': 25}, {'name': 'Jack', 'age': 19}, {'name': 'Smith', 'age': 20}]匿名函数当作实参的应用：
python2：
#coding=utf-8
def calcu(a,b,func):
result = func(a,b)
return result
func_new=input("请输入计算规则: ")
result=calcu(11,12,func_new)
print result
>>> 请输入计算规则: lambda x,y:x*y
>>> 132
python3：(python3中的input会把输入的内容当作字符串处理 所以要用eval 将字符串转换成表达式)
def calcu(a,b,func):
result=func(a,b)
return result
func_new = input("请输入计算规则：")
func_new = eval(func_new)
print(calcu(11,12,func_new))
>>> 请输入计算规则：lambda x,y:x-y
>>> -11.5 文件
文件的复制、粘贴
1.6 面向对象
定义一个类：
class 类名:
函数列表综合案例：
class cat:
"""定义了一个cat类"""
#初始化对象
def __init__(self,new_name,new_age):
self.name=new_name
self.age=new_age
def __str__(self):
return "%s的年龄是%d"%(self.name,self.age)
#方法
def eat(self):
print("%s在吃鱼..."%self.name)
def drink(self):
print("%s在喝水..."%self.name)
#创建一个对象
tom=cat("汤姆猫",16)
tom.eat()
print(tom)
smith=cat("咖菲猫",1)
smith.drink()
print(smith)
>>> 汤姆猫在吃鱼...
>>> 汤姆猫的年龄是16
>>> 咖菲猫在喝水...
>>> 咖菲猫的年龄是1
注：
- 创建完对象
__init__默认执行 - 在python中方法名如果是
__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法 - 当使用print输出对象的时候，只要自己定义了
__str__(self)方法，那么就会打印从在这个方法中return的数剧
__del__() 方法
由上可知，python解释器默认调用 __init__()方法
当删除一个对象时，python解释器也会默认调用一个方法，这个方法为 __del()__方法
import time
class Animal(object):
#初始化方法
#创建完对象后会自动被调用
def __init__(self,name):
print("__init__方法被调用")
self.__name=name
#析构方法
def __del__(self):
print("__del__方法被调用")
print("%s对象马上被干掉了..."%self.__name)
#创建对象
dog = Animal("哈皮狗")
#删除对象
del dog
cat = Animal("波斯猫")
cat1 =cat
print("马上删除cat对象")
del cat
print("马上删除cat1对象")
del cat1
print("程序两秒后结束")
time.sleep(2)
1.6.1 封装与隐藏
Python中没有像C++中public和private这些关键字来区别公有属性和私有属性
它是以属性命名方式来区分，如果在属性名前面加了2个下划线__，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）
为了更好的保存属性安全，即不能随意修改，一般的处理方式为
- 将属性定义为私有属性
- 添加一个可以调用的方法，供调用
class People(object):
def __init__(self,name):
self.__name=name
def getName(self):
return self.__name
def setName(self,newName):
if len(newName) >= 5:
print("newName的长度:%s"%(len(newName)))
self.__name = newName
else:
print("error:名字长度需要大于或者等于5")
xiaoming = People("haha")
print(xiaoming.getName())
xiaoming.setName("SmithDavid")
print(xiaoming.getName())
>>> haha
>>> newName的长度:10
>>> SmithDavid- 私有的属性，不能通过对象直接访问，但是可以通过方法访问
- 私有的方法，不能通过对象直接访问
- 私有的属性、方法，不会被子类继承，也不能被访问
- 一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用
1.6.2 继承
即一个派生类（derived class）继承基类（base class）的字段和方法
单继承-示例：
# 定义一个父类,如下
class Cat(object):
def __init__(self,name,color="白色"):
self.name = name
self.color = color
def run(self):
print("%s--跑啊跑"%self.name)
#定义一个子类
class Bosi(Cat):
def setNewName(self,newName):
self.name=newName
def eat(self):
print("%s--在吃呀吃"%self.name)
bs = Bosi("波斯猫")
print("bs的名字:%s"%bs.name)
print("bs的颜色:%s"%bs.color)
bs.eat()
bs.setNewName("波斯花花猫")
bs.run()
>>> bs的名字:波斯猫
>>> bs的颜色:白色
>>> 波斯猫--在吃呀吃
>>> 波斯花花猫--跑啊跑
说明：
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法
多继承-示例：
扫一扫
1575
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
