python。如图，为什么第一个print的\t不起作用，无法对齐下面的，该怎样做？

Posted 2023-04-07

这个看方法，这类问题基本没关注过，但是可以自己写一个对齐函数，对于同一列的数据把长度规定死就是几个字符的长度，这个长度必须涵盖最大的字符，小于这个长度的在两边自动填补空格，这样每列都像表格一样包裹在一个范围内自己就对齐了，直接用\\b有一定的局限性，一旦四个字符补充不了就会偏左，有英文字符或者其他情况就会偏右，不好控制，每个字符再打打印前处理一下就OK，示例如下：

参考技术A 转义字符\t对应的是一个tab也就是4个空格。所以你上面的print打印了四个汉字加4个空格，肯定和下面字母对应的是不一样的。 参考技术B 汉字占两个字节，字母占一个。
print("学员姓名\t学员性别\t学员手机号")
print("aa","aa","aa",sep="\t")
print("aaa","aaa","aaa",sep="\t")
这样写试试
只需要对齐你就这样，在\t前面加一个空格，英文需要加两个\t
print("学员姓名 \t学员性别 \t学员手机号")
print("a \t\taa \t\taaa") 参考技术C \t的作用是插入一个制表符, 而制表符有一个特点, 如果要显示的字符超过一个制表符的宽度, 会顺延到下一个制表符的位置, 这里明显是"学员姓名"占了两个制表符的位置, 而后面的"学员性别"只能从第三个制表符的位置开始显示, 于是就看到了图中的效果
要解决这个问题, 可以使用Python的格式化字符串来指定每个字符串显示的宽度
比如:
"%-10s" % "学员姓名"
这里10表示这个字符串要显示为10个字符的长度, 不足的部分用空格来补齐
这里的"-"表示左对齐, 不加"-"就表示右对齐
使用这种方法就可以控制字符串的输出的对齐方式了 参考技术D 这个占位需要计算的数量的，有一个命令可以强制对齐，你可以查一下追问

那个命令可以强制对齐？

python基础学习第六天

import os

#文件读写 不用自动关闭
with open(‘test.txt‘,‘r‘) as f:
    #一次性读取所有
    data = f.read()
    #print(data)
print(‘---------循环打印------------‘)
with open(‘test.txt‘,‘r‘) as f:
    for line in f:
        if line==‘‘:
            print(‘遇到
换行符‘)
        else:
            #为什么输出是换行？
            print(line)
with open(‘test.txt‘,‘w‘) as f:
    f.write(‘你好
‘)
    f.write(‘热烈欢迎
‘)
#line1=‘我爱北京‘
#line2=‘天安门‘
#with open(‘test.txt‘,‘w‘) as f:
#    print(line1,file f)
#    print(line2,file f)
#nt表示是window
print(os.name)
#环境变量
print(os.environ)
#操作文件与目录
print(os.path.abspath(‘.‘))
#在某个目录下面创建一个新的目录
print(os.path.join(‘batmanpythondemo‘,‘pictures‘))
#os.rmdir(‘E:\batman\python\demo\pictures‘)
#os.mkdir(‘E:\batman\python\demo\pictures‘)
#os.rename(‘学习目标.txt‘,‘learntarget.txt‘)
#os.remove(‘learntarget.txt‘)

#复制文件os没有提供 可以使用shutil
#import shutil 学习！！！
#shutil.copyfile(‘E:\batman\python\demo\learntarget.txt‘,‘E:\batman\python\demo‘)

print(‘-------------序列化和反序列化------------------‘)
import pickle

d=dict(name=‘王晓春‘,age=30,adress=‘安徽‘)
#调用dumps函数进行序列化
str=pickle.dumps(d)
print(str)
f=open(‘dump.txt‘,‘wb‘)
#将序列化的内容写入到f文件中
pickle.dump(d,f)
f.close()
#使用json序列化
import json

d=dict(name=‘小四‘,age=28,adress=‘潮州‘)
str=json.dumps(d)
print(str)
#调用loads反序列化
d=json.loads(str)
print(d)
#求绝对值得函数 abs
print(abs(-100))
print(type(abs))
#abs 具有复制的能力
f=abs
print(f(-99))
def add(x,y,f):
    return f(x)+f(y)
print(add(-4,4,abs))
print(‘----------匿名函数------------‘)
sum=lambda arg1,arg2:arg1+arg2
print(sum(1,2))
#reduce内建函数是一个二元操作函数，用来将一个数据集合(列表、元组)中的所有数据进行如下操作：传给reduce中的函数
#func()必须是一个二元操作函数先对集合中的第1,2个数据进行操作，得到的结果在与第三个数据用func()函数进行运算
from functools import reduce

l=[1,2,3,4,5,6,7,8]
print(reduce(lambda x,y:x+y,l))
#给一个初始值，放在list后面
print(reduce(lambda x,y:x+y,l,10))
#map函数
new_list=list(map(lambda i:i+1,l))
print(new_list)
l2=[2,3,4]
new_list=list(map(lambda x,y:x+y,l,l2))
print(new_list)
#filter()函数可以对序列做过滤处理，把序列的每一项传到自定义的过滤函数里面处理
f1=[33,44,55,666]
new_list=list(filter(lambda x:x<100,f1))
print(new_list)

print(‘----------装饰器------------‘)
def hello(fn):
    def wrapper():
        print(‘hello, %s‘ %fn.__name__)
        #回调函数
        fn()
        print(‘goodbye, %s‘ %fn.__name__)
    return wrapper()

#hello注解 hello函数中返回了一个inner函数wrapper,这个wrapper函数回调了传过来的fn
#并在回调前后加了两条语句
#可以理解为把一个函数传到另外一个函数中，在回调自己
@hello
def foo():
    print(‘i am foo‘)
foo()
#斐波那契数列递归算法
from functools import wraps
def memo(fn):
    cache={}
    miss=object()

    @wraps(fn)
    def wrapper(*args):
        result=cache.get(args,miss)
        if result is miss:
            result=fn(*args)
            cache[args]=result
        return result
    return  wrapper

@memo
def fib(n):
    if n<2:
        return n
    return fib(n-1)+fib(n-2)

print(‘---------动态添加属性和方法-----------‘)
#动态给对象添加属性和方法
from types import MethodType

#__slots__限制添加属性和方法
class MyClass(object):
    __slots__ = [‘name‘,‘set_name‘]

def set_name(self,name):
    self.name=name

mycls=MyClass()
mycls.name=‘jack‘
mycls.set_name=MethodType(set_name,mycls)
mycls.set_name(‘tom‘)
print(mycls.name)
#限制对继承类不起作用
class YoursClass(MyClass):
    pass

youcls=YoursClass()
youcls.age=30
print(youcls.age)

import traceback

class Student:
    @property
    def score(self):
        return self._score

    @score.setter
    def score(self,value):
        if not isinstance(value,int):
            raise ValueError(‘not int‘)
        elif value<0 or value>100:
            raise ValueError(‘not between‘)
        self._score=value

    #只读属性
    @property
    def double_score(self):
        return self._score * 2

s=Student()
s.score=75
print(s.score)
print(s.double_score)
try:
    s.double_score=150
except AttributeError:
    traceback.print_exc()

#自己实现描述器 __set__/__get__/__del__
class MyProperty:
    def __init__(self, fget=None, fset=None, fdel=None):
        print(fget)
        self.fget=fget
        self.fset=fset
        self.fdel=fdel

    def __get__(self,instance,cls):
        if self.fget:
            self.fget(instance)

    def __set__(self, instance, value):
        if self.fset:
            self.fset(instance,value)

    def __del__(self, instance):
        if self.fdel:
            self.fdel(instance)

    def getter(self,fn):
        self.fget=fn

    def setter(self,fn):
        self.fset=fn

    def deler(self,fn):
        self.fdel=fn

class Student2:
    @MyProperty
    def score(self):
        return self._score

    @score.setter
    def set_score(self,value):
        self._score=value

s=Student2()
s.score=95
print(s.score)