分类 python 下的文章

说起python的字符串替换我们可能会想到的就是使用 replace函数

比如有一段字符串 "这是简单替换",我们想把 "简单" 替换为 "复杂":

>>> s = "这是简单替换"
>>> s.replace("简单","复杂")
'这是复杂替换'

根据 replace 函数的设定,他只能处理一组映射关系的替换,所以在替换多组数据时我们可能要使用多个replace进行类似嵌套的操作,这在数据量大的情况下显得很鸡肋而且影响代码美观。

如 "101010" 使用替换的方法使之变成 "010101",也就是 "1" 和 "0" 互换,这时候的表达式可能会写:

>>> s = "101010"
>>> s.replace("1","a").replace("0","1").replace("a","0")
'010101'

上述操作虽然能达到目的,但是看起来效果很鸡肋,完全时靠 replace 进行的逐个替换,而且替换有交集时还得使用临时交换,当数据量很大时总不能写 N 个replace吧,那这时候就有了另一个比较简便的方法:

>>> s = "101010"
>>> trans = s.maketrans("1 0","0 1")
>>> s.translate(trans)
'010101'

关于 maketrans 方法

关于 translate 方法

在大量的替换处理中就会变得非常便捷

Readme:可自动识别需要加密还是解密,如:

C:\cmd>python3 morse.py "123456"

[+]"123456"的加密结果:.----/..---/...--/....-/...../-....

C:\cmd>python3 morse.py ".----/..---/...--/....-/...../-...."

[-]".----/..---/...--/....-/...../-...."的解密结果:123456

源码如下:

#/usr/bin/python3
# _*_ coding:utf-8 _*_
import sys

"""对照表"""
t = {"A": ".-", "B": "-...", "C": "-.-.", "D": "-..", 
	 "E": ".", "F": "..-.", "G": "--.", "H": "....",
	 "I": "..", "J": ".---", "K": "-.-", "L": ".-..",
	 "M": "--", "N": "-.", "O": "---", "P": ".--.",
	 "Q": "--.-", "R": ".-.", "S": "...", "T": "-",
	 "U": "..-", "V": "...-", "W": ".--", "X": "-..-",
	 "Y": "-.--", "Z": "--..",
	 "1": ".----", "2": "..---", "3": "...--", "4": "....-",
	 "5": ".....", "6": "-....", "7": "--...", "8": "---..",
	 "9": "----.", "0": "-----",
	 "(": ".--.-", "-": "-....-", "?": "..--..", "/": "-..-.","_":"..--.-",
	 ".": ".-.-.-", "@": ".--.-.", ")": "-.--.-", "}":"-----.-","{":"----.--",
	 
	 '.-': 'A', '-...': 'B', '-.-.': 'C', '-..': 'D', '.': 'E',
	 '..-.': 'F', '--.': 'G', '....': 'H', '..': 'I', '.---': 'J',
	 '-.-': 'K', '.-..': 'L', '--': 'M', '-.': 'N', '---': 'O',
	 '.--.': 'P', '--.-': 'Q', '.-.': 'R', '...': 'S', '-': 'T',
	 '..-': 'U', '...-': 'V', '.--': 'W', '-..-': 'X', '-.--': 'Y', '--..': 'Z',
	 '.----': "1",'..---': '2', '...--': '3', '....-': '4', '.....': '5', '-....': '6',
	 '--...': '7', '---..': '8', '----.': '9', '-----': '0',
	 '.--.-': '(', '-....-': '-', '..--..': '?',"-.--.-":")", "-----.-":"}","----.--":"{",
	 '-..-.': '/', '.-.-.-': '.', '.--.-.': '@',"..--.-":"_",
	 }



def edcode(p):
	s = ''
	if './' in p or '-/' in p:   # 判断输入的字符串是要加密还是解密
		"""解密"""
		for i in p.strip('/').split('/'):   # 循环取出每一个解密的元素
			s += t[i]   # 进行对照表解密
			
		print('\n[-]"{}"的解密结果:'.format(p) + s)    # 打印结果
			
	else:
		"""加密"""
		for i in list(p):
			s += t[i.upper()] + '/'	# 每个字符加密后拼接一起,使用'/'隔开
			
		print('\n[+]"{}"的加密结果:'.format(p) + s.strip('/'))   # 首尾去'/',打印结果
	
if __name__ == '__main__':
	if len(sys.argv) == 2:   # 判断是否按照指定格式运行脚本
		try:
			p = sys.argv[1]   # 取需要加密或者解密的参数
			edcode(p)
		
		except:   # 人生如戏,难免发生意外,提示运行错误
			print("\n[!]请检查输入的参数是否合法,暂时只支持字母数字和一下特殊字符:'_','-','.','@','/','?'")
			
	else:
		print("""
[*]使用方法:python3 this.py "要加密或者解密的字符串"
[+]加密:python3 morse.py "123456"
[-]解密:python3 morse.py ".----/..---/...--/....-/...../-...."   # 解密一定要带有 '/'符号,不然识别不出
			""")

前言:

对象是模拟真实世界,把数据和程序进行封装 。

对象 = 属性+ 方法

我们需要用类来创造一个对象,就像我们要用图纸来造房子一样。在Python中函数名是以小写字母开头 ,类名是以大写字母开头。

0x00:面向对象(Object Oriented)我们一般称为OO,OO的特征有

1.封装

就像我们对列表的操作一样,很多方法已经封装好了,我们只需要调用自己需要的方法的名字就好了

>>> list1 = [2,1,7,4,3]
>>> list1.sort()
>>> list1
[1, 2, 3, 4, 7]
>>> list1.append(9)
>>> list1
[1, 2, 3, 4, 7, 9]
>>>

2.继承

继承是子类自动共享父类之间数据和 方法的机制

>>> class Mylist(list):
	pass
 
>>> list2 = Mylist()
>>> list2.append(5)
>>> list2.append(6)
>>> list2
[5, 6]
>>> list2.append(3)
>>> list2.sort()
>>> list2
[3, 5, 6]
>>> 

我们创建的类可以继承列表的很多属性

3.多态

多态就是不同对象对同一方法响应不同的行动


>>> class A:
	def fun(self):
		print('我是0verflow')
 
		
>>> class B:
	def  fun(self):
		print('我是XX')
 
		
>>> a = A()
>>> b = B()
>>> a.fun()
我是0verflow
>>> b.fun()
我是XX
>>>

我们上面的程序用到了self,但是它 什么东西我们并没有解释,其实它就相当于一个序号

>>> class Ball:
	def setname(self,name):
		self.name = name
	def kick(self):
		print('谁踢我%s。。。。。'  % self.name)
 
		
>>> a = Ball()
>>> a.setname('A')
>>> b = Ball()
>>> b.setname('B')
>>> c= Ball()
>>> c.setname('C')

0x01:python的 魔法方法 __init__(self)(构造方法):

__init__(self ,  param1, param2...)


>>> class Ball:
	def __init__(self,name):
		self.name = name
	def kick(self):
		print('我叫%s' % self.name)
 
		
>>> b = Ball('0verflow')
>>> b.kick()
我叫0verflow
>>> a = Ball()
Traceback (most recent call last):
  File "<pyshell#54>", line 1, in <module>
    a = Ball()
TypeError: __init__() missing 1 required positional argument: 'name'
>>>

因为我们设置了默认参数如果不传入参数就会报错  。

0x02:公有和私有

公有和私有的意义这里我就不解释了,就是字面意思

默认来说对象的属性和方法都是公有的,为了实现私有Python内部给出了一个name mangling(名字改编,名字重整)的机制

在python中定义私有变量只需要在变量名或函数名前加上‘’__‘’两个下划线,Python所谓的私有只是意义上的,为什么这么说看下面的代码大家就明白了。


>>> class Person:
	name =  '0verflow'
 
	
>>> p = Person()
>>> p.name
'0verflow'
>>> class Preson:
	__name = '0verflow'
 
	
>>> p = Person()
>>> p.__name
Traceback (most recent call last):
  File "<pyshell#65>", line 1, in <module>
    p.__name
AttributeError: 'Person' object has no attribute '__name'
>>>

针对上面的代码想打印私有还是可以的,不过要多写一个函数:


>>> class Preson:
	__name = '0verflow'
	def getname(self):
		return self.__name
 
	
>>> p = Preson()
>>> p.getname()
'0verflow'
>>>

其实我们也可以通过另一种方式:_类名__变量名


>>> class Preson:
	__name = '0verflow'
	def getname(self):
		return self.__name
 
>>> p._Preson__name
'0verflow'
>>>

这里我们在来说一下继承

被继承者我们 称为基类或父类,继承者我们称为子类,子类可以继承父类的属性和方法。

>>> class Parent:
	def hello(self):
		print('正在调用父类的方法')
 
		
>>> class Child(Parent):
	pass
 
>>> p = Parent()
>>> p.hello()
正在调用父类的方法
>>> c = Child()
>>> c.hello()
正在调用父类的方法
>>> class Child(Parent):
	def hello(self):
		print('正在调用子类的方法')
 
		
>>> c = Child()
>>> c.hello()
正在调用子类的方法
>>> p.hello()
正在调用父类的方法
>>>

在举一个例子说明一下:


import random as r
 
 
class Fish:
      def __init__(self):
            self.x = r.randint(0,10)
            self.y = r.randint(0,10)
            
      def move(self):
           self.x -= 1
           print('我的位置是:',self.x ,self.y)
 
class Goldfish(Fish):
      pass
class Carp(Fish):
      pass
class Shark(Fish):
      def __init__(self):
            self.hungry = True
 
      def eat(self):
            if self.hungry:
                  print('饿了,要进食')
                  self.hungry = False
            else:
                  print('吃饱了')

从上面的例子运行的结果可以看出,我们在让shark移动的时候莫名其妙的报错了,原因是因为我们从新定义了__init__()所以覆盖掉了父类的方法和属性。针对 这个问题有两种解决的办法:

1.使用未绑定的父类

看一下运行的结果:


>>> fish = Fish()
>>> fish.move()
我的位置是: 2 8
>>> goldfish  = Goldfish()
>>> goldfish.move()
我的位置是: 9 0
>>> shark = Shark()
>>> shark.eat()
饿了,要进食
>>> shark.eat()
吃饱了
>>> shark.move()
Traceback (most recent call last):
  File "<pyshell#101>", line 1, in <module>
    shark.move()
  File "D:\Python\test\test.py", line 10, in move
    self.x -= 1
AttributeError: 'Shark' object has no attribute 'x'
>>>

import random as r
 
 
class Fish:
      def __init__(self):
            self.x = r.randint(0,10)
            self.y = r.randint(0,10)
            
      def move(self):
           self.x -= 1
           print('我的位置是:',self.x ,self.y)
 
class Goldfish(Fish):
      pass
class Carp(Fish):
      pass
class Shark(Fish):
      def __init__(self):
            Fish.__init__(self)
            self.hungry = True
 
      def eat(self):
            if self.hungry:
                  print('饿了,要进食')
                  self.hungry = False
            else:

我们增加了一行代码 :Fish.__init__(self)这行代码中的self已经不是父类的self了,而是子类的self

运行的结果:


>>> shark = Shark()
>>> shark.move()
我的位置是: -1 3
>>>

2、super()


import random as r
 
 
class Fish:
      def __init__(self):
            self.x = r.randint(0,10)
            self.y = r.randint(0,10)
            
      def move(self):
           self.x -= 1
           print('我的位置是:',self.x ,self.y)
 
class Goldfish(Fish):
      pass
class Carp(Fish):
      pass
class Shark(Fish):
      def __init__(self):
            super().__init__()
            self.hungry = True
 
      def eat(self):
            if self.hungry:
                  print('饿了,要进食')
                  self.hungry = False
            else:
                  print('吃饱了')

这种方法是将上一种方法的那一条添加的语句改为: super().__init__()

看一下运行的结果:


>>> shark = Shark()
>>> shark.move()
我的位置是: -1 5
>>> 

第二种方法比较简单便捷,所以我们一般情况会用第二种方法。

多重继承:一个子类可以继承多个父类的属性和方法


>>> class Base1:
	def fool1(self):
		print('我是fool1')
 
		
>>> class Base2:
	def fool2(self):
		print('我是fool2')
 
		
>>> class C(Base1,Base2):
	pass
>>> c  = C()
>>> c.fool1()
我是fool1
>>> c.fool2()
我是fool2
>>> 

多继承很容易导致一些不可知的错误,所以一般情况下我们是不使用的。