【python篇】python基础之--基本问题记录

第一：保留字

python的保留字
查看所有的保留字命令：【在ipython里操作 退出用：quit】
import keyword
keyword.kwlist

and     as      assert     break     class      continue    def     del      elif    else    except     exec      finally    for         from    global      if      in      import     is        lambda     not         or      pass      print   raise   return     try       while      with        yield

第二：变量类型

python的变量类型

1.整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
2.浮点数
3.字符串
4.布尔值
5.空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

三、运算 （部分）

** ：幂
// ：取整除

四、print()的使用（格式化）

1. 接多个字符串 ：print(“i”,”am”,”winner”)
2.接表达式： print(100+200)
3.变量替换：a=25 print(“我的年龄为：%d岁”%a) 输出为：我的年龄为：25岁
4. 拓：a=25 b=1 name=尘世星空 print(“我的年龄为：%d岁”%(a+b,name))
备注：
d:整数替换 s:所有类型替换
%d：整数 %f：浮点数 %s：字符串【所有】 %x：十六进制整数
5. 拓：money=2 print(“人民币为：%d元”%money) 结果：人民币为：00002元
6.精确位数
w=3.1415926 print(“圆周率：%.2f”%w) 3.14
w=3.1415926 print(“圆周率：%d.00”%w) 3.00
w=3.1415926 print(“圆周率：%.2f”%%w) 3.14%

五、列表操作

列表中存放的数据是可以进行修改的，比如”增”、”删”、”改””
<1>.添加元素(“增”append, extend, insert)
<2>. 修改元素(“改”)
<3>. 查找元素(“查”in, not in, index, count)
<4>. 删除元素(“删”del, pop, remove)
del：根据下标进行删除，其实可以删除所有变量
pop：默认删除最后一个元素
remove：根据元素的值进行删除第一个
注： append 和insert的区别在于，append追加的单个记录往里放，insert的插入的需要和原始数据的规模一致。

l
['abcdef', ['aaa', 'bb', 'ccc'], 'ddd', 'fff']
 del  l[0]
 l
[['aaa', 'bb', 'ccc'], 'ddd', 'fff']

备注：del 列表名 则删除列表

<5>. 排序(sort, reverse)
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
reverse方法是将list逆置。

<6>. enumerate()

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
备：列表也可以通过[]*n 进行乘法扩展。字符串、元组都可以。

举例：

names=['c','x','2011','年']
names2=('c','x','2011','年')

j=0
print("序号\t姓名")
for i in names2:#while :
    j+=1
    print("%d\t%s"%(j,i))

print("="*30)

第二种 枚举的使用 
for i,item in enumerate(names,1): // 如果加1 使得序号从1开始。
    print("%d\t%s"%(i,item))
结果为：
序号  姓名
1   c
2   x
3   2011
4   年
 ================================
1   c
2   x
3   2011
4   年

六、元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
需要注意的是有，range函数的使用，在python2和python3中是不同的。python3中是懒加载的。c=range(1,10) 输出c不能直接得到列表。需要拿到里面的元素。但是python2是可以直接拿到列表的。

备注：
不可变类型 ：整型、字符串、元组
数值类型 是不可表类。如果赋值变了，只是说明其引用变了，或者说指向变了。并没有改变原来的数值。新开辟内存空间存放新值。
字符串也是不可变类型。
查看内存地址使用：id(XXX变量名) // 在ipython中操作较方便
可变类型：list 列表
eg:
c=[1,2,3]
x=c 此时 id(c)=id(x) 说明它们指向了同一个内存地址
x+=[4,5,6] 查看x=[1,2,3,4,5,6] 在查看c同样被改变了。
注意：
x+=[] 与 x=x+[] 两者的结果是不一样的。对于后者等号的后面如果是表达式，则会先执行，此时会得到一个全新的列表。而前者还以前的列表。因此不同。

基本数据类型：
python的整型是没大小限制的。java的的一个整型占4个字节。4*8=32位。可表示最 大的数为：2^32 - 1

七、字典

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
赋值：stus={‘id’:10, ‘name’:’chen’, ‘age’:25}
获取：stus[‘age’] 或 stus.get(‘age’)
修改：stus[‘age’]=30
查找：如果使用 in 用key 来判断 eg:name in stus 返回True 或直接用获取的方式
删除 ：del stus[‘age’] 使用del内存会立马备回收 但是 clear() 不会立马回收。
字典的常见函数key、value、items、len()、has_key。
字典遍历
<1>遍历字典的key（键）
<2> 遍历字典的value（值）
<3> 遍历字典的项（元素）
<4> 遍历字典的key-value（键值对）

举例：

stu={"id":0, "name":"chenshi","age":25}

for k in stu.keys():
    print(k) // 只打印key

for v in stu.values():
    print(v) // 只打印value

print("="*30)

for item in stu.items(): // 字典里的items()方法 
    print(item) // 打印key 和 value  

# 拓展
for item in stu.items(): 
    print("key:%s\tvalue:%s"%item)

上述拓展的方式item实际的格式应该是：(a,b)。元组，item本身就是一个元组。
因此可以那么使用。

八、循环

while循环注意事项：

  1 age=int(input("请输入年龄："))
  2 i=1
  3 while i < 10:  # while True
  4     if i == age:
  5         print("猜对了,你的年龄为：%d"%i)
  6         break
  7     else:
  8         print("猜错了")
  9     i+=1

while后接else。以及和continue外的print可以打印。

  1 i = 0
  2 while i < 10:
  3     i+=1
  4     if i % 2 == 0:
  5         print("%d是偶数"%i)
  6     continue
  7     print("当前的i 是%d"%i)
  8 else:
  9     print("else 表示不满足条件时调用的代码，这时i为%d"%i)
  10 print("结束")

结果为：
2是偶数
4是偶数
6是偶数
8是偶数
10是偶数
else 表示不满足条件时调用的代码，这时i为10
结束

以下操作可在ipython下操作。

for循环

格式：for 变量 （该变量不需要在前申明） in 字符串或者集合
如果里面字符串或者集合为空了，则到else：

下标索引获取：
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’
倒序写法：
a[-1::-1] 起始–>结束–>步长
for后接else表示for循环的额条件不再满足，

备注:仅在python2中有的
a=raw_input(“请输入”) print(a) 如果在python3中会报方法未定义
input的方法在python2和python3中都有，但是，2中input函数输入的内容作为表达式。而不是字符串。而3作为字符串。都当字符串！！
比如：
a=input(“请输入姓名：”)
print(a)
python2中：输入2+2 python3中：sfsdfsdfsd
对于print，python2可以不用加括号。而3必须用括号。

真假问题：

 age=int(input("请输入值:"))
  if age:
      print("age 非 0")
  else:
       print("age = 0")

   name=""
   if name:
      print("name 不是一个空字符串")

九、函数

python常用内置函数：
cmp 在python2中
注意：cmp在比较字典数据时，先比较键，再比较值。
del有两种用法，一种是del加空格，另一种是del()
多维列表/元祖访问的示例
tuple1 = [(2,3),(4,5)]
tuple1[0] (2, 3)
tuple1[0][0] 2

对不可变类型的全部变量要想修改其值，其本质上上修改其不可变类型的全局变量的引用 使用global XXX 来修改再改值。加了global才可以修改其的引用（指向）。
全部变量定义在调用函数前就可以，不一定非要定义在被调用函数体内。
eg:

  1 names=["chen","xiao","2011","年"]
  2 names2=names
  3 student={"name":"chenxiao"}
  4 a="smile"
  5 b=100
  6 
  7 def test():
  8     names=[1,2,3,4,5]
  9     print("原始的全局变量为：%s"%names)
 10     names[2]="xiaosmile"
 11     student["age"]=23
 12 
 13     global a
 14     a="chenshixingkong"
 15     global b
 16     b+=1
 17 
 18 test()
 19 print("最后的全部变量为:%s"%names)
 20 print("最后的全部变量为：%s"%student)
 21 print("a=%s"%a)

9.1函数的封装

  1 def printinfo(name, age=10):
  2     print( "Name", name)
  3     print( "Age", age)
  4 
  5 printinfo(name="cx", age=1)

注意：
封装的函数如果带有默认值，则此参数一定要位于参数列表的最后面。
对调用函数而言，对传参的顺序不要求。

总结如下：

1、在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
2、对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。
3、对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。
4、可变类型：值可以修改（内存地址不变但是所保存的值变化了），引用可以修改（变量的内存地址变化了）
不可变类型：值不可以修改，可以修改变量的引用（=赋值号）。
eg:
a=[1,3,4]
a.append(5)
比较a的地址没有变，id(a)相同。但是如果a=[5,6,7] 此时a的引用变了。id(a)不再相同。

定义可变长参数用法：

  1 def test(x,y,*args):  // def test(x,y,*args,z=10):
  2     print(x,y)
  3     print(args)
  4     sum = x + y
  5     for i in args:
  6         sum += i
  7     print("和为%s"%sum)
  8 
  9 test(1,2,3,4,5)        //  test(1,2,3,5,z=20)

对自定义的参数，调用时候需要对给指定的参数名赋值。

 11 def test2(x,*args,**kwargs):
 12     print(x)
 13     print(args)
 14     print(kwargs)
 15 
 16 test2(2,3,4,num1=5,num2=33) 

----------
  1 def test(x,y,*args,**chenx):
  2     print(x,y)
  3     print(args)
  4     sum = x + y
  5     for i in args:
  6         sum += i
  7     print("和为%s"%sum)
  8     for i in chenx.values():
  9         sum += i
 10     print("和为%s"%sum)
 11 test(1,2,3,4,5,cx=1,cxx=2) 

----------
结果为：
1 2
(3, 4, 5)
和为15
和为18 

9.1 封装函数
在python中可不可以返回多个值？

>>> def divid(a,b):
...     shang = a//b
...     yushu = a%b
...     return shang, yushu
... 
>>> sh, yu = divid(5, 2)
>>> sh
>>> yu

9.2 动态匿名函数的使用

  1 #encoding=utf-8
  2 def test(a,b,func):
  3     result=func(a,b)
  4     return result
  5 
  6 
  7 func_new=input("请输入你的操作：")
  8 func_new=eval(func_new)
  9 print(test(1,3,func_new))

运行：

lambda x,y:x/y
0.3333333333333333

字符串切割用法：
my_str.partition(“xxx”) // 把切割条件带上

my_str.split(” “, 2) // 只把前2个按空格切割

help(my_str.find) // 查看方法的用法

部分细节：
1.python的true和false首字母都是大写的。True。 False
2.python2和python3的字符集问题，2有时候需要指定
3.None是python的空值。处理java中的nullpoint
4. if-elif-else 的使用

十、文件操作.
readlines 、read。以及readline
对于readlines和read而言，如果read不接参数，它们俩的功能是一样的，是把整个文件都读取出来。而readline是按行读的。

 1 source_file="/root/jw.txt"
  2 dest_file="copy-"+source_file[source_file.rfind("/")+1:]
  3 print("目标文件名字：%s"%dest_file)
  4 
  5 #打开文件
  6 source_f=open(source_file) # 如果目标文件是压缩文件需
  7 dest_f=open(dest_file,"w")
  8 
  9 #读取原始文件
 10 content=source_f.read()
 11 
 12 #把读取的内容写到目标文件中
 13 dest_f.write(content)
 14 
 15 #关闭文件
 16 source_f.close()
 17 dest_f.close()

递归求目录寻找含有cx字样并以.py结尾的文件。

  1 import os
  2 file_list=[]
  3 
  4 def find_hello(dir):
  5     if os.path.isdir(dir):
  6         pass
  7     else:
  8         if dir.endwith(".py"):
  9             if read_and_find_hello(dir):
 10                 file_list.append(dir)
 11 
 12 
 13 def read_and_find_hello(py_file):
 14     flag=False
 15     f=open(py_file)
 16     line=f.readline()
 17     while True:
 18         line=f.readline()
 19         if line=='':
 20             break
 21         elif "cx" in line:
 22             flag=True
 23             break
 24     f.close()
 25     return flag
 26 
 27 print(read_and_find_hello("/root/cx.py"))

十一、面向对象

  1 class User:
  2 
  3     def __str__(self):
  4         return "用户名为：%s，密码为：%s"%(self.username,self.password)
  5 
  6     def set_password(self,pw):
  7         if len(pw) >= 6:
  8             self.password=pw
  9         else:
 10             print("密码%s,长度不符合规定"%pw)
 11 
 12 u1=User()
 13 #u1.password="cckkkx"
 14 #u1.username="cx"
 15 u1.set_password("cxxxxp")
 16 print(u1)

python私有方法/属性命名以”__”开头。

Python中没有像C++中public和private这些关键字来区别公有属性和私有属性
它是以属性命名方式来区分，如果在属性名前面加了2个下划线’__’，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。

__init__()方法，在创建一个对象时默认被调用，不需要手动调用

__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)

__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去

del方法的使用：

  1 class User:
  2     def __init__(self):
  3         print("====对象初始化===")
  4 
  5     def __del__(self):
  6         print("对象即将要备销毁，（内存回收）")
  7 
  8 u=User()
  9 del u
 10 print("---"*10)

结果为：

====对象初始化===
对象即将要备销毁，（内存回收）
------------------------------

十二、继承：

  1 class Animal:
  2 
  3     def eat(self):
  4         print("----吃饭----")
  5     def sleep(self):
  6         print("---睡觉---")
  7 
  8 class Dog(Animal):
  9 
 10     def shout(self):
 11         print("---旺旺叫---")
 12 
 13 class Cat(Animal):
 14 
 15     def catch(self):
 16         print("---抓老鼠---")
 17 
 18 
 19 dog=Dog()
 20 dog.eat()

备注：子类继承父类的方法一定是公有的。私有的不可被继承。

多继承：

 1 class A:
  2     def test(self):
  3         print("A--test")
  4 
  5 
  6 class B:
  7     def test(self):
  8         print("B--test")
  9 
 10 class C(A,B):
 11     def test1(self):
 12         print("C---test")
 13 
 14 c=C()
 15 c.test()

备注：继承的优先级，看需要继承的类里继承的类的先后顺序，比如第十行，A在前，则先继承A。

重写
super().init(name)

类属性和类方法
类方法
是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字，就最好用’cls’了），能够通过实例对象和类对象去访问。
类属性和类方法的删除只能通过类名来操作。del

总结

new至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

new必须要有返回值，返回实例化出来的实例，这点在自己实现new时要特别注意，可以return父类new出来的实例，或者直接是object的new出来的实例
init有一个参数self，就是这个new返回的实例，init在new的基础上可以完成一些其它初始化的动作，init不需要返回值

我们可以将类比作制造商，new方法就是前期的原材料购买环节，init方法就是在有原材料的基础上，加工，初始化商品环节

十三、单例模式

  1 class User(object):
  2     __instance=None
  3     def __init__(self,name):
  4         self.name=name
  5 
  6     @classmethod
  7     def get_instance(cls,name):
  8         if not cls.__instance:
  9             cls.__instance=User(name)
 10         return cls.__instance
 11 u1=User("cc")
 12 u2=User("xx")
 13 
 14 #u1=User.get_instance("cx")
 15 #u2=User.get_instance("cxxx")
 16 
 17 print(u1==u2)
 18 print("u1对象的内存地址：%s，u2对象的内存地址：%s"%(id(u1),id(u2)))

注释的运行结果为：
False
u1对象的内存地址：139906817488152，u2对象的内存地址：139906817488208

未注释的结果为：
True
u1对象的内存地址：140394413565208，u2对象的内存地址：140394413565208

说明：一个类多次的使用获取实例，不再是单例。而同一个类反复调同一个方法获取实例，是单例的。

另一种单例的方式

  1 class User(object):
  2     __instance=None
  3     def __init__(self,name):
  4         self.name=name
  5 
  6     def __new__(cls,name):
  7         if not cls.__instance:
  8              cls.__instance=object.__new__(cls)
  9         return cls.__instance
 10 
 11 u1=User("cc")
 12 u2=User("xx")
 13 
 14 print(u1==u2)
 15 print("u1对象的内存地址：%s，u2对象的内存地址：%s"%(id(u1),id(u2)))

十三、工厂模式
工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量(可维护性)。

class Person(object): 
    def __init__(self,name): 
        self.name=name 
    def work(self,axe_type): 
        print(self.name+"开始工作了")     
        #person完成work，需要使用一把斧头         
        #在原始社会，人需要一把石斧 
        #axe = StoneAxe("花岗岩斧头")         
        #使用钢铁的斧头 
        #axe = SteelAxe("加爵斧头")         
        #已经有工厂 
        axe =Factory.create_axe(axe_type) 
        axe.cut_tree() 
class Axe(object):     
    def __init__(self,name): 
        self.name=name 
    def cut_tree(self): 
        print("%s斧头开始砍树"%self.name) 
class StoneAxe(Axe):     
    def cut_tree(self): 
        print("使用石头做的斧头砍树") 
class SteelAxe(Axe):     
    def cut_tree(self): 
        print("使用钢铁做的斧头砍树") 
#工厂类
class Factory(object): 
    #生产斧头，根据用户指定的类型来生产 
    @staticmethod 
    def create_axe(type):     
        if type=="stone": 
            return StoneAxe("花岗岩斧头")
        elif type=="steel": 
            return SteelAxe("加爵斧头")
        else: 
            print("传入的类型不对") 
p = Person("zs")
p.work("steel")

十四、包

14.1 模块
随机数打印

  1 import random as rm
  2 #print(random.randint(0,5))
  3 print(rm.randint(1,4))

另一种导入方式：

 from random import randint
 print(randint(0,5)) #注意不可使用random.randint(0,5) 

备1：把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明： from modname import *
也可以使用自己制作的模块。如果两个模块中方法名字相同，则后面覆盖前面

备2：定位模块
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
当前目录
如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
备3: 测试模块
可以根据name变量的结果能够判断出，是直接执行的python脚本还是被引入执行的，从而能够有选择性的执行测试代码
if name == ‘main’ #由python解释器主动执行该模块为了测试
#主要是模块被导入，就会自动执行

python中的包
1. 引入包
1.1 包就是一个目录
1.2 把多个py文件放到同一个文件夹下
1.3 使用import 文件夹.模块 的方式导入
python3可以导入包,python2不行。
1.4 使用from 文件夹 import 模块 的方式导入
python3可以导入包,python2不行。
1.5 兼容py2，可在包的文件夹下创建_init_.py文件。
在python2中：有一个目录，并且目录下有一个init.py的文件。才叫包。
虽然文件内容没有，但是python2可以用了
有init.py文件在python3中没有有错。以后我们都在包的目录下新建一个init文件。
1.6 如果只想引入包，而不报错，需要在_init_.py文件中写入
from . import 模块1
from . import 模块2
那么可以使用import 文件夹 导入
1.7 也可以使用from 文件夹 import 模块 的方式导入

14.2 模块的发布和安装

创建一个test_pub的文件夹,将包放在test_pub文件夹中,然后在与包同级的目录中创建一个setup.py的文件
1.mymodule目录结构体如下：
tree 命令查看
2.编辑setup.py文件
py_modules需指明所需包含的py文件

from distutils.core import setup
 setup(name="压缩包的名字", version="1.0", description="描述", author="作者", py_modules=['suba.aa', 'suba.bb', 'subb.cc', 'subb.dd'])

3.构建模块
python setup.py build
4.生成发布压缩包
python setup.py sdist

此时查看目录会多出一个以压缩包名字命名的压缩文件。

模块安装、使用
1.找到模块的压缩包（拷贝到其他地方）
2.解压
3.进入文件夹
4.执行命令python setup.py install

注意：
如果在install的时候，执行目录安装，可以使用python setup.py install –prefix=安装路径

14.3 列表推导公式
1、给程序传参数

import sys 
print(sys.argv)

2、列表推导式
1、所谓的列表推导式，就是指的轻量级循环创建列表：
a = [i for i in range(1,10)]
b= [i*2 for i in range(1,10)] // [2,4,6,8….]
2、在循环的过程中使用if 来确定 列表中元素的条件
a = [i for i in range(1,10) if i%2==0]
**3、**2个for循环
a=[x for x in range(1,2) for y in range(0,4)]
[1, 1, 1, 1]
a=[(x,y) for x in range(1,2) for y in range(0,4)]
[(1, 0), (1, 1), (1, 2), (1, 3)]

set：集合类型