python 基础

  • 时间:
  • 来源:互联网

一、python环境安装

1、python 2.7 安装
2、python 3.5 安装
(配置环境变量)
3、pycharm安装
破解
a、license server 输入地址激活:http://xidea.online
b、百度pycharm 注册码

二、使用pycharm

2.1、python2.7 中文编码

# -- coding:utf-8 -- 注释:只能放到文件的第一行或者第二行(官方文档)

2.2、python 基本数据类型

标准数据类型:
number (数字): 用id()查看内存地址,type()查看数据类型
整数类型 int:
长整数类型 long:
浮点数类型 float:
复数类型 complex
string (字符串)
bool(布尔值)True 和 False 常用到if 和while中应用
none (特殊常量)
容器数据类型:
list(列表) []
tuple(元组) ()
dictionary (字典) {}
set (集合)

2.3、变量

a、声明变量 先赋值后使用
变量名区分大小写
关键字不能作为变量名
除了下划线,其他符合不能作为变量名
数字不能作为变量名的开头

2.4、程序基本组成以及输入输出

2.4.1、python中的注释

单行注释 #开头
多行注释 “”” “”” 快捷键 ctrl+/
中文注释 编码格式,#coding:utf-8

2.4.2、输出

print语法形式

(1)、使用加号运算符:

str1 = “罚抄”
str2 = 3
str3 = “遍”
# 使用反引号
print str1+str2+str3
# 使用str()发放进行数据类型转换
print str1+str(str2)+str3

(2)、使用逗号连接符

str1 = “罚抄”
str2 = 3
str3 = “遍”
# 使用反引号
print str1,str2,str3

(3)、格式化输出字符串

#1.字符串占位%s
print “His name is %s ” %”Jack”
#2.整数占位%d
print “He is %d years old” %30
#3.浮点数占位%f
print “His high is %f m” %(1.83)
print “His high is %.3f m” %(1.83)
# 4.指定占位符的宽度
print(“Name: %10s Age:%8d Height:%8.2f” % (“Jack”, 25, 1.83))
print(“Name: %-10s Age:%-8d Height:%-8.2f” % (“Jack”, 25, 1.83))

(4)、.format() :让输出格式更清晰

# 普通格式输出
print “%s is %d years old” % (“Jack”,20)
# format格式输出
print “{0} is {1} years old” .format(“Jack”,20)

(5)、结果定义连接符

print (‘123’,’234’,’456’)
print (‘123’,’234’,’456’,sep=”-“) # python3
# 是否换行
print(“222”,end=”“)
print(“333”)

2.4.3、输入

(1)、raw_input类型 输入任意类型,输入都是字符串 str

num1 = raw_input(“请输入第一个数字:”)
num2 = raw_input(“请输入第二个数字:”)
# 都为字符串,所以结果为连接
print num1+num2
# 转换为int之后,结果为相加
print int(num1)+int(num2)

(2)、input类型 输入python表达式

注:python3中默认接收的是str类型
num3 = input(“请输入10+5:”)
print(num3)

2.5、容器数据类型

2.5.1、列表 list = [‘a’,’Jack’,1,2,3]

a、创建列表

list1 = [‘h’,’e’,’l’,’l’,’o’]
list2 = list(‘hello’) #用来把str转换成list
print list1
print list2
#切片
list1 = [‘physics’,’chemistry’,1997,2000]
list2 = [1,2,3,4,5,6,7,8,9]

print list1[0]
print list2[1:5]

list3 = [1,2,3,’abc’,5,6,7]
print list3[:3],list3[3],list3[4:]
print list3[:]

b、更新列表

# 更新列表
list4 = [1, 2, 3, 4]
list5 = list4[:] #复制一份,内存地址发生变化
# 修改list4
list5[3] = 5
print list5
print list4
# append()在结尾再添加一个对象 注:对象包括字符串或者列表
list4 = [1, 2, 4, 5]
list4.append(3)
list4.append(list3)
print list4
print list4[4][3] # 多维数据读取
list.extend(a,b) 约等于 list+[a,b] #一次性添加多个元素

c、删除列表

list1 = [‘physics’,’chemistry’,1997,2000]
del list1[2] #删除某个元素
del list1[2:3] #删除某段区间,右区间未开区间,不包括
del list1 #删除整个列表,内存会释放,变为未定义
del list1[:] #清空, 等于list[0:len(list1)]
print list1
pop() 默认删除结尾
pop(index) 删除index位的值dict

d、列表脚本操作符

len([1,2,3]) 3
[1,2,3]+[1,2,3,4] [1, 2, 3, 1, 2, 3, 4]
[‘Hi!’] *4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]
3 in [1,2,3] True

e、列表索引、截取(切片)

list5 = [‘abc’,123,456,’hello’,[123]]
print list5[-1]
print list5[-5:]

2.5.2、元组 tup1 = (’aa’,22,55)

python中元组与列表相似,不同之处在于元组的元素不能修改
注意: a = (‘Hello’) 和a= (‘Hello’,),不一致,前一个是str,后一个是tuple

a、创建元组

tup1 = (‘abc’, 1, 2)
tup2 = “a”, “b”, “c”, “d”
#通过tuple()函数转化为元组
tup3 = tuple(“hello”)
tup4 = tuple([1,2,3])
tup5 = tuple(4,5,6)

b、访问元组

tup1 = (‘physics’, ‘chemistry’, 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print “tup1[0]: “, tup1[0]
print “tup2[1:5]: “, tup2[1:5]

c、修改元组

元组中的元素值是不允许修改的,但我们可以对元组进行连接组合
print tup1 + tup2

d、删除元组

元组中的元素值是不允许修改的,但我们可以对元组进行连接组合
del tup1

e、元组运算符

len([1,2,3]) 3
[1,2,3]+[1,2,3,4] [1, 2, 3, 1, 2, 3, 4]
[‘Hi!’] *4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]
3 in [1,2,3] True
迭代
tup = (‘Jack’, ‘miki’, ‘zhangsan’, ‘lisi’, 1, 2)
for x in tup:
print x

#中文坑
tup = (‘Jack’, ‘miki’, ‘张三’, ‘李四’, 1, 2)
for x in tup:
print x
print tup
(‘Jack’, ‘miki’, ‘\xe5\xbc\xa0\xe4\xb8\x89’, ‘\xe6\x9d\x8e\xe5\x9b\x9b’, 1, 2) #打印中文变成乱码
解决方法: 加json.dumps(tup).decode(“unicode-escape”)
import json
tup = (‘Jack’, ‘miki’, ‘张三’, ‘李四’, 1, 2)
for x in tup:
print x
print json.dumps(tup).decode(“unicode-escape”)

2.5.3、字典 dict = {key1:value1,key2:value2}

1、字典 python中另一种可变容器模型 ,键是唯一的,值不一定

变量名 = {key1:value1,key2:value2}

2、创建字典

# 创建字典
dict = {} #不要以dict做为变量名,否则dict()不可用
print dict
dict[“age”] = 20
print dict
#赋值式的添加或创建# person = {‘name’:’qiwsir’,’language’:’python’}
#无序读取,效率高# print person# person[‘name2’] = ‘qiwsir2’
#用[]法读取# print person
#通过dict()把元组转换为字典
tup = ([‘name’,’zhangsan’],[‘name2’,’lishi’]) #注意:元组的长度为2
website = dict(tup)
print website# 直接使用key=value的方法# ad = dict(name=’zhangsan’, age=220) # 或者使用key=value的方法
# print ad#使用formkeys()
web = {}.fromkeys((‘first’,’second’),’zhangsan’)
web = {}.fromkeys((‘first’,’second’),(‘zhangsan’,’lishi’))
print web

3、访问字典

只要知道key,就能得到值,本质是映射关系
# person = {‘name’:’qiwsir’,’language’:’python’}
# print person[‘name’]

4、修改字典

dict = {‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’}
dict[‘Age’] = 8
dict[‘School’] = “DPS School”
print “dict[‘Age’]: “, dict[‘Age’]
print “dict[‘School’]: “, dict[‘School’]

5、删除字典

打印字典不存在的key或删除清空后的字典都会报错
import json
#删除字典元素
dict1 = {‘name’:’小李’,’age’:’17’,’sex’:’男’}
print json.dumps(dict1).decode(“unicode-escape”)
print dict1[‘name’]
del dict1[‘name’]
dict.clear() # 清空词典所有条目
del dict # 删除词典
print dict1[‘name’] #打印删除的key,会报错
print json.dumps(dict1).decode(“unicode-escape”)

2.5.4、集合

1、集合 set

能够索引的 下标list/str
可变的
不可变的
无索引序列的
集合就是以上几点的合并

2、创建集合

#字符串变为集合
set1 = set(‘hello’)
print set1
print type(set1)
# 列表变为集合
list1 = [1,2,3,4]
set2 = set(list1)
print set2
#字典变为集合
dict1 ={“name”:”zhangsan”,”name2”:”laochai”,’num’:[3,4]}
set3 = set(dict1)
print set3
#直接写
set4 = {‘k1’,’k2’,’k3’,’k4’}
print set4

3、集合的基本操作

a、比较

se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be) # 类似去交集,返回新值,保留原值se
print temp1

se1 = {11, 22, 33}
be1 = {22, 55}
temp2 =se1.difference_update(be1) #将去掉交集后的结果覆盖到原值
print temp2
print se1

b、取交集

se = {11, 22, 33}
be = {22, 55}
temp1 = se.intersection(be) #取交集,赋给新值
print(temp1) # set([22])
print(se) # set([33, 11, 22])
temp2 = se.intersection_update(be) #取交集并更新自己
print(temp2) # None
print(se) # set([22])

c、判断

se = {11, 22, 33}
be = {22}
print(se.isdisjoint(be)) #False,判断是否不存在交集(有交集False,无交集
True)
print(se.issubset(be)) #False,判断se是否是be的子集合
print(se.issuperset(be)) #True,判断se是否是be的父集合

d、合并

se = {11, 22, 33}
be = {22}
temp1 = se.symmetric_difference(be) # 合并不同项,并赋新值
print(temp1) # set([33, 11])
print(se) # set([33, 11, 22])
temp2 = se.symmetric_difference_update(be) # 合并不同项,并更新自己
print(temp2) #None
print(se) # set([33, 11])

e、更新

se = {11, 22, 33}
be = {22,44,55}
se.update(be) # 把se和be合并,得出的值覆盖se
print(se)
se.update([66, 77]) # 可增加迭代项
print(se)

f、转换

se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st)

2.6、运算符

2.6.1算术运算符、

a = 18;b = 10;c = 0
c = a + b
print (“1 – c 的值为:”, c)
# 1 – c 的值为: 28
c = a - b
print (“2 – c 的值为:”, c)
# 2 – c 的值为: 8

2.6.2比较运算符

a = 18
b = 10
if a > b:
print “a大于b”
else:
print “a小于或等于b”

2.6.3赋值运算符

a = 10
b = 5
c = 0
c+=a #c=c+a
b-=a #b=b-a
print c,b

2.6.4 逻辑运算符

and 、or、 not、
2.6.5 位运算符
& |
2.6.6 成员运算符
in 、 not in
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print (“1 - 变量 a 在给定的列表中 list
中”)
else:
print (“1 - 变量 a 不在给定的列表中
list 中”)

2.6.7 身份运算符

is 、 is not
# is 判断内存地址是否相同 == 是判断值是否相等
a = 1
b =1
print id(a),id(b)

2.6.8 运算符优先级

2.7、表达式

1、数学运算表达式

1 + 2 ; 2 / 3 ; 20 % 3

2、逻辑运算表达式

True and False ; True or False ; not True

3、比较运算表达式

1 > 2 ; 2 <= 4 ; 5 ! = 6 ;

4、Python中表达式都有值,其值就是表达式运算后的结果

.
流程控制
if语句
if …elif…else
if …else

作业:
1、输入三个整数x,y,z,请把这三个数由大到小输出。
2、依次输入三角形的三边长,判断能否生成一个三角形。
3、依次输入三角形的三边长,判断能否生成一个等腰三角形。
4、依次输入三角形的三边长,判断能否生成一个直角三角形。
提示 :a**n 表示 a 的 n 次方。
5、猜拳游戏:
用户输入石头、剪刀或布,电脑也会出一个招,要求得出
最终结果,显示胜利玩家。
提示1:用数字代表猜拳
提示2:使用条件判断语句
提示3:
import random
random.randint(m,n )为取m-n随机整数的方法

回顾,总结
1、a、b 互换
a,b = b,a
a,b,c=b,c,a
2、判断用户输入是否是一个number
.strip(‘-’)默认去掉首尾的空格符,也可以指定去除某符号
.isdigit() 默认判断是不是一个数
a = raw_input(“请输入一个数”)
if a.strip().isdigit():
print a
else:
print “不是一个整数”
3、# 谁大取谁
aa = 40
bb = 30
cc = 0
if aa > bb:
cc == aa
else:
cc == bb

cc = aa if aa>bb else bb

4、循环

4.1while 循环

while count < 10:
print “count is “, count
count = count + 1 # count+=1
print “循环结束”

# count = 0
# while count < 10:
#     print count, "小于", 10
#     count += 1
# else:
#     print count, "大于", 10

count =1
while count < 10:
if count %2 ==0:
print count,”是偶数”
else:
print count,”是奇数”
count += 1

4.2 for 循环

for item in iterable iterable 可迭代的
for …… else

遍历字符串
a = ‘python’
i = 0
while i < len(a):
print a[i],
i += 1

k = 0
while k in range(len(a)):
print a[k],
k +=1
#for循环读取
for x in a:
print x,

# 以下标方式读取
for x in range(len(a)):
print a[x],

4.2.1 使用range for循环遍历

for x in range(len(a)):
print a[x],

4.2.2 使用zip for循环遍历

zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,
然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致,则返回列表
长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表
a = [5, 6, 7, 8, 9]
b = [5, 4, 3, 2, 1]
c = []
# for x,y in zip(a,b):
# c.append(x + y)
# print c

list1 = [‘hello’,’world’,’yes’]
list2 = [1,2,3]
list3 = [‘hao’,’nao’,’good’]
#
# print zip(list1,list2)
# print zip(list2,list1)

d = []
for x,y,z in zip(list1,list2,list3):
d.append(x +”:” + str(y)+”:”+z)
print d

# 返回字典的所有键
print dict1.keys()
# 返回字典的所有值
print dict1.values()

#输出letter的下标
letter = [‘a’,’b’,’c’,’d’,’e’]
# for i in range(len(letter)):
# print str(i+1),letter[i]

for index,value in enumerate(letter):
print value,’is’,index+1

4.3 for 循环嵌套

# 输出直接*三角形
i = 0
while i < 6:
j = 0
while j <= i:
print “*”,
j +=1
i +=1
print ”

for i in range(1,7):
for j in range(i):
print “*”,
print “”

4.4 推导式

# 1.输出1-10的平方数
a = [x ** 2 for x in range(1, 10)]
print a
# 2.输出1,3,5,7,9
b = [x for x in range(1, 10, 2)]
print b
# 3.输出2,4,6,8,10
c = [x for x in range(2, 11, 2)]
d = [x for x in range(2, 11) if x % 2 == 0]
print c
print d
#4.大小写转换
print [x.lower() for x in list(‘ABddCD’)]
print [x.upper() for x in list(‘abcdAA’)]

4.4.1字典推导式

#5.字典推导式
print {i:i**2 for i in range(5)}
print {i:j for i,j in zip(range(5),’abcd3’)}

#输入名字,打印出对应的值
city = {‘zhangsan’:[‘a’,’b’],’lisi’:[1,2,3]}
name = raw_input(“请输入名字:”)
for name in city.keys():
for i in city[name]:
print i

4.5 循环控制

break语句
continue语句 #停止当前循环,跳出该次循环
pass语句

#求1-100内的质数
#被1和本身整除
# i =1
# c = []
# while (i<=100):
#     j = 2
#     while (j <= i ):
#         if i % j == 0:
#             if i==j:
#                 # c.append(i)
#                 print i,
#             break
#         j += 1
#     i+=1
# print c

#2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 []

for i in range(2,17):
for j in range(2,i):
if i % j ==0:
break
else:
print i,

5. python函数

5.1python函数定义和使用

def printme(str1): #str1 参数
#输出指定内容
print str1
printme(‘第一次’)
printme(11111)
a = ‘value’
printme(a)

5.2 python参数传递

值传递和引用传递,在python中,string、tuples和numbers是不可更改的对象,是值传递。而 list,dict则是可以修改的对象,是引用传递。

5.2.1值传递

值传递叶称为不可变类型
值传递值传递也称为不可变类型, 类似 c++ 的值传递, 如 整数、 字符串、 元组。 如printme(a) , 传递的只是a的值, 没有影响a对象本身。 比如在 printme(a) 内部修改 a 的值, 只是修改另一个复制的对象, 不会影响 a 本身。
# a = ‘12345’
# def printme(a):
# a = 234
# print a
# printme(a)
# print a

5.2.2引用传递

引用传递也称为可变类型: 类似 c++ 的引用传递,如 列表,字典。如 printme(la),
则是将 la 真正的传过去,修改后printme外部的la也会受影响。示例如下:

5.2.3 参数类型

#1.必备参数
# def printme(str):
# print str
# printme(‘haha’)
# #2.关键字参数
# printme(str=3)
#3.缺省参数
# def printInfo(name,age=25):
# print “姓名:”,name
# print “年龄:”,age
#
# printInfo(‘Jack’,20)
# printInfo(‘tom’)
#4.不定长参数
“””
1、*args与**kwargs 名称可以变化
2、 *args 收集的是 元组
3、 **kwargs 收集的是字典
“””
def funC(x,y,z,*args,**kwargs):
print x,y,z
print args
print kwargs
funC(1,2,3,4,5,6,a=”zhangsan”,age=25)

def homework(x):
print ‘我已经写完了’,x,’题了’
return ‘写完了’
result = homework(3)
print result

5.3 python返回值

return 语句
该语句表示退出函数,在函数中可存在可不存在,当存在时向调用方返回一个表达式
的值。不带参数值的return语句返回值为None。
return
1.1 结束函数
1.2 第二个return不执行
1.3 用于闭包

5.4 python匿名函数

lamabda
filter
map
reduce

5.5 python函数对象与闭包

def funA():
pass
funA.alert = ‘hello’
funA.hobby = [‘play’,’eat’]
funA.pp = lambda :”haha”

print funA.alert
print funA.hobby
print funA.pp()

5.6 python装饰器

6 python面向对象

6.1Python 编程方式

面向过程:根据业务逻辑从上到下写垒代码
函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可
面向对象:对函数进行分类和封装,让开发“更快更好更强…”

6. 2、 Python 面向对象概念

面向对象就不像面向过程那样按照功能划分模块了,它所关注的是软件系统有哪些参与
者,把这些参与者称为对象,找出这些软件系统的参与者也就是对象之后,分析这些对
象有哪些特征、哪些行为,以及对象之间的关系,所以说面向对象的开发核心是对象

6. 3、 Python 类与对象

1、什么是类
面向对象编程的2个非常重要的概念:类和对象
概念:类是用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个
对象所共有的属性和方法。对象是类的实例。
2、什么是对象
万物皆对象,对象拥有自己的特征和行为。
3、类和对象的关系
类是对象的类型,对象是类的实例。类是抽象的概念,而对象是一个你能够摸得着,看
得到的实体。二者相辅相成,谁也离不开谁。

6. 4、 类的声明和实例化

1、 创建类

使用class语句来创建一个新类, class之后为类的名称并以冒号结尾
class Car:
“车的类型”
doors =4
def init(self, name, color):
self.name = name
self.color = color

def showCarInfo(self):
    print "This car is called%s,%s" % (self.name, self.color)

2、 实例化类

#实例化对象
car1 = Car(’ BMW’,’Black’)
car2 = Car(’ qq飞车’,’Yellow’)

3、 如何调用类的方法

car1.showCarInfo()
car2.showCarInfo()
print car1.doors

4、 构造函数

init(): 是一个特殊的方法属于类的专有方法, 被称为类的构造函数或初始化方
法,方法的前面和后面都有两个下划线。这是为了避免Python默认方法和普通方法发
生名称的冲突。每当创建类的实例化对象的时候, init()方法都会默认被运行。
作用就是初始化已实例化后的对象。

5、 self

self 代表类的实例, self 在定义类的方法时是必须有的,虽然在调用时不必传入相应的数。
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例
它的名称是 self。 self并不是Python的关键字,你完全可以用其他单词取代他,只是按照惯例和标准
的规定,推荐使用self。
示例: self.class 则指向类。 self 不是 python 关键字,我们把他换成 selfParam 也是可以正
常执行的

6、 类变量

empCount 变量是一个类变量,它的值将在这个类的所有实例之间共享。你可以在内
部类或外部类使用 Employee.empCount 访问。 类变量通常不作为实例变量使用。如
果需要用在函数中使用类名.类属性.

6. 5、 类的属性和方法

1、 操作类的属性

常见针对类的属性的一些方法
可以使用实例化对象名+.来访问对象的属性
也可以使用以下函数的方式来访问属性
getattr(obj, name[, default]) : 访问对象的属性
hasattr(obj,name) : 检查是否存在一个属性
setattr(obj,name,value) : 设置一个属性。如果属性不存在,会创建一个新属性
delattr(obj, name) : 删除属性
注意:name需要加单引号,obj为实例化对象名称

2、 内置类属性

dict : 类的属性(包含一个字典,由类的数据属性组成)
doc :类的文档字符串
name: 类名
module: 类定义所在的模块
bases : 类的所有父类构成元素(包含了一个由所有父类组成的元组)

3、 类的私有属性和私有方法

(1)类的私有属性
__private_attrs:两个下划线开头,声明该属性为私有,不能在类的外部被使用或
直接访问。在类内部的方法中使用时 self.__private_attrs。
(2)类的方法
在类的内部,使用 def 关键字可以为类定义一个方法,与一般函数定义不同,类方
法必须包含参数 self,且为第一个参数
(3)类的私有方法
__private_method:两个下划线开头,声明该方法为私有方法,不能在类地外部
调用。在类的内部调用 self.__private_methods
#公有的和私有的类
class JustCounter:
__private_count=0
public_count = 0
def init(self):
passb
def count(self):

    self.__private_count +=1        #访问私有变量self
    JustCounter.public_count +=1    #访问公有变量使用className

6. 6、 类的继承

1、类继承的概念
继承,面向对象中的继承和现实生活中的继承相同
2、 多重继承
如果在继承元组中列了一个以上的类,那么它就被称作”多重继承”
3、 方法重写
如果你的父类方法的功能不能满足你的需求,你可以在子类重写你父类的方法

本文链接http://element-ui.cn/news/show-576559.aspx