python基础 字符串常见操作

No1：

单行注释：#

多行注释：前后加'''或者前后加"""

No2：

开头增加#coding=utf-8解决中文无法解析的问题

或者#-*- coding:utf-8 -*-

No3:

打印数字

age =18
print("age变量里的值是%d"%age)

打印字符

name = "哥哥"
print("name变量的值是%s"%name)

No4：

5//2等于2   取商

5/2等于2.5　正常除法

2**3等于8　　2的三次方

"hello"*10　　10个"hello"拼接

print("姓名是：%s，年龄是：%d，地址是：%s"%(name,age,addr))　　--多个变量输出值

No5:

vi编辑模式下ctrl+n是代码提示

No6：

if a="" and/or b="" and/or c="":
   print("")

vi 文件名 +行数            打开文件vi编辑模式同时跳到指定行数

if not (a>0 and a<=50):
    print("")

if a = "":
    print("")
elif a = ""
    print("")
elif a = ""
    print("")

切片

name="abcdefg"

name[2:6]=cdef

name[2:-1]=cdef

name[2:]=cdefg

name[2:-1:2]=ce

name[-1::-1]=gfedcba

No7:

info = {键:值,键:值,...}　　 字典

No8:

列表的添加方式：append(内容)、insert(坐标，内容)、extend(新列表)

列表的删除方式：pop()、remove(内容)-删第一个、del 列表[坐标]

if 内容 （not） in 列表  -返回true

 No9：

def fun(a,b=33)

缺省参数只能放在后边定义

fun(11,c=44)

指定参数的值，命名参数

No10：

def fun(a,b,*args):
    print(a)
    print(b)
    print(args)

*args是不定长参数，args打印出来是一串元组

No11：

def fun(a,b,c,**kwargs):

fun(1,2,3,task=44,done=99)

---------------
a
b
c
{'task',44,'done':99}

**kwargs也是不定长参数，打印出来的是字典

No12：

def test(*args,**kwargs):
    print(args)
    print(kwargs)

A = (44,55,66)
B = {"name":"laowang","age":18}

test(*A,**B)
-----------
(44,55,66)
{"name":"laowang","age":18}

这里*A和**B的作用是将对应的元组或字典拆成一个一个的元素

No13:

id(对象名) 查看对象的引用地址

No14：

数字类型、字符串类型、元组类型是不可变类型（即不可修改其中的元素）

列表和字典是可变类型（可以修改其中的元素）

列表不能做字典的键

No15：

匿名函数

fun = lambda a,b:a+b

默认return的就是a+b

调用匿名函数

result = func(11,22)

infors.sort(key=lambda x:x['name'])

def test(a,b,func):
    result = func(a,b)
    print(result)

test(11,22,lambda x,y:x+y)

动态匿名函数

func_new = input("请输入一个匿名函数：") //python2的写法
func_new = eval(func_new) //python3将字符串转为命令

test(11,22,func_new)

No16：

交换两个变量的值

a = a + b
b = a - b
a = a - b

a,b = b,a

No17:

num+=num
和
num = num + num
的区别：
第一个指向的还是同一个对象
第二个指向的却是一个新的对象

【字符串常见操作】

myStr = "hello world itcast and hahaitcastcpp"

No1：

myStr.find("world")

myStr.rfind("world") //从右边开始的字符串下标

No2:

myStr.index("world")

myStr.rindex("itcast") //返回最右边的字符串下标

No3:

myStr.count("itcast") //有多少个

No4:

myStr.replace("world","WORLD")

No5:

myStr.split(" ")
myStr.split() //按照不可见符号切割

No6:

myStr.capitalize() //将第一个字母变大写

No7：

myStr.title() //将所有单词首字母大写

No8：

myStr.startswith(obj) //判断是否以obj开头
myStr.endswith(obj) //判断是否以obj结尾

No9：

myStr.lower() //将所有字母变为小写
myStr.upper() //将所有字母变为大写

No10：

myStr.ljust(int) //在宽int列中左对齐
myStr.center(int) //在宽int列中居中
myStr.rjust(int) //在宽int列中右对齐

No11：

myStr.lstrip() //删除左边的空格
myStr.rstrip() //删除右边的空格
myStr.strip() //删除左边和右边的空格

No12：

myStr.partition(obj) //以obj为中心分开
myStr.rpartition(obj) //从右边以obj为中心分开

和split不同的是，split不保留，partition保留

No13：

myStr.splitlines() //按换行符（\n）切割并换行

No14：

myStr.isalpha() //判断是否纯字母
myStr.isdigit() //判断是否纯数字
myStr.isalnum() //判断是否字母或数字的组合
myStr.isspace() //判断是否纯空格

No15：

names = ["aaa","bb","cc"]
a = "_"
a.join(names)  //连接
----------------
'aaa_bb_cc'

以上

【文件操作】

No1：

f = open('test.txt','w')

w是覆盖，a是追加

r+/w+用于读写

f.close() //关闭文件

f.write(obj) //写文件

f.read(int) //接着往后读int个字符

读完、写完都要关闭

No2：

f.readlines() //按行读所有字符
f.readline() //读一行

No3：

f.seek(offset,方向)  //offset：微调偏移量；方向：0-向开头方向，1-当前位置，2-向结尾方向
f.tell() //告诉当前的位置

No4：

import os

os.rename(旧文件名，新文件名);  //重命名
os.remove(文件名)  //删除文件
os.mkdir(新文件名)  //创建新文件夹
os.getcwd() //获取当前目录
os.chdir(目录) //改变当前目录
os.listdir(目录) //列举目录下文件

No18:

class Cat:
     def __init__(self,__name,__age):
         self.name = __name
         self.age = __age
 
     def __str__(self):
         return "%s的年龄是%d"%(self.name,self.age)
 
     def eat(self):
         print("猫吃鱼....")
 
     def drink(self):
         print("猫喝可乐...")
 
     def introduce(self):
         print("%s的年龄是%d"%(self.name,self.age))
 tom = Cat("汤姆",40)
 
 tom.eat()
 tom.drink()
 print(tom)                                

注解：__init__俗称魔法方法，是一定会执行的，在__new__方法执行之后

__str__相当于java里的toString()方法

No19:

#私有方法
def __send(self):
    print()

#公有方法
def send(self,money):
    if money>100:
       self. __send()
    else:
        print()

函数前面加两个下划线就是私有方法，想调用私有方法都是先创建公有方法去调

No20：

class Dog:
    def __del__(self):
        print()

dog = Dog()
//__del__在对象无人引用或程序结束时会调用

No21：

sys.getrefcount(obj)
//查看obj对象被引用的次数

No22：

class Animal:
    def eat(self):
        print()

class Dog(Animal):
    pass

class Cat(Animal):
    pass

继承

No23：

class Animal:
    def bark(self):
        print()

class Dog(Animal):
    def bark(self):
　　　　 print
　　　　 1）Animal.bark(self)
　　　　 2）super().bark()


//重写，先去找子类的方法，再去找父类的方法
//在子类中可以调用父类的同名方法,有两种方法

No24：

私有属性和方法不会被子类继承

No25:

class A:
    pass

class B:
    pass

class C(A,B):
    pass

多继承

No26：

类名.__mro__：调用一个方法，在子父类中搜索的顺序

No27：

类方法

class Game(object):
    
    num = 0
    
    @classmethod
    def add_num(cls):
        cls.num = 100


Game.add_num()
print(Game.num)

注：类的对象也可以调用类方法

No28：

静态方法

class Game(object):
    @staticmethod
    def print_menu():
        print()


Game.print_menu()

注：类的对象也可以调用静态方法

No29：

class Dog(object):
    def __new__(cls):
        return object.__new__(cls)

__new__方法相当于java中的空参构造方法，返回的是创建的类的对象的引用给__init__方法

__init__相当于java的初始化，将传递进的参数赋值。

所以说，java的构造方法相当于__new__加上__init__之和。

No30：

单例模式

__instance = None
def __new__(cls):
    if cls.__instance == None:
        cls.__instance = object.__new__(cls)
        return cls.__instance
    else:
        return cls.__instance

No31：

抓取异常

try:   
    

except NameError:
    print()

try:
    XXX
---python2的写法
except NameError,IOError:
   print()
---python3的写法        
except (NameError,FileNotFoundError):
    print()

---其他的所有异常
except Exception as ret(自己命名):
    print(ret)--可打印错误的内容
---没有异常才会执行的功能
else:
    print()
---最后一定会执行的功能
finally:
    print()

---抛出异常
if XXX:
    raise 自定义异常

 No32：

0表示假，非0表示真

 No33：

模块的调用

sendmsg.py:
    
    def send():
        print("XXX")
    def receive():
        print("XXX")

main.py:

    import sendmsg
    sendmsg.send()
    sendmsg.receive()

    或者

    import sendmsg as sd
    sd.send()
    sd.receive()

    或者
    
    from sendmsg import send,receive(或*)
    send()
    receive()

import模块的时候会将模块里的代码执行一遍

if __name__ == "__main__"：
    print()

如果在模块中加入以上代码，则模块在自己执行的时候会print()，模块被调用的时候，__name__会变成模块的名字，print就不会执行。这样就能做到自测和联调区分

No34:

//供别人调用的东西，包括类、函数、变量
__all__ = ["test1"]

def test1():
    print("----test1----")
def test2():
    print("----test2----")


这样的话，别人import的时候，就只能用test1，不能调用test2

如果一个文件夹下包含几个py文件，且文件夹里有__init__.py文件，则这个文件夹称之为包。
__init__.py：
    __all__ = [py文件名，不要后缀]


则可以impor这个包，且能调用里面的py文件和方法

或者from . import 模块名

No35：

文件名.__file__打印模块所在路径

No36：

给程序传参数

import sys

print(sys.argv)

name = sys.argv[1]

print("热烈欢迎%s的到来"%name)


-------运行
python3 py名字 参数1 参数2...
-------打印
['py名字','参数1','参数2']
热烈欢迎参数1的到来

No37：

range返回的是一个列表

range的风险：python2中如果申请了一个很大的内存空间，程序不会通过；python3返回的还是range，需要使用的再生成需要的某个结果，解决了这个问题

列表生成式：

a = [i for i in range(1,18)]
a
---结果
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17]

b = [11 for i in range(1,18)]
b
---结果
[11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11]

c = [i for i in range(10) if i%2==0]
c
---结果
[0,2,4,6,8]

No38:

集合

c = {11,22,33,11,22,33}
c
--结果
{11,22,33}

元组、列表、集合可以相互强转

No39：

 1+2在python2输出的是3，在python3输出的是“1+2”