一、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        #访问私有变量selfJustCounter.public_count +=1    #访问公有变量使用className

6. 6、 类的继承

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