python实例化类传list

❶ python的问题，关于类中定义的列表，求大神解答

当实例化对象的时候，新的实例得到是类属行的一个引用，这个引用不能说是可读的，可读不可读都是针对所引用的这个属性是否可变，数字，字符串是不可边的数据类型，而list或者自定义对象等都是可变类型
class a:
b=4
List=[];
test1=a()
test1.b=5
test1.List.append("11")
test2=a()
print (test2.List),(test2.b),(test1.b)
>>>
['11'] 4 5
>>>
http://my.oschina.net/emrys/blog/89652

❷ python中怎么初始化list

Python中，tuple和list均为内置类型， 以list作为参数将tuple类初始化，将返回tuple类型 tuple([1,2,3]) #list转换为tuple以tuple作为参数将list类初始化，将返回list类型 list((1,2,3)) #tuple转换为list

❸ 请问python中类的属性怎么初始化为一个列表

你的表述很有问题，问题本身便是错的。
列表与其他类型的数据一样，都可以作为实参传入类和函数，而python在定义形参的时候是不指定类型的，所以完全不知道你为何有此一问。
但不论如何，你可以参考以下代码。
class Student:
def __init__(self, name, age, scorelist): #构造函数，第一个参数为实例本身，按要求后接三个形参
self.name = name #属性：姓名
self.age = age #属性： 年龄
self.scorelist = scorelist #属性：成绩列表
def get_name(self):
return str(self.name)
def get_age(self):
return int(self.age)
def get_course(self):
return int(max(self.scorelist))
#self.scorelist便是传入的list实参，用max()函数取出最大值，再强制转换为int型。
zm = Student('zhangming',20,[69,88,100])
print(zm.get_name())
print(zm.get_age())
print(zm.get_course())

❹ python 实例化类时不传入某个变量的值

使用默认参数。

classa(object):
def__init__(self,b,c=None):
self.b=b
self.c=c

m=a(1)#m.c为None

❺ thrift c++ list 怎么用python客户端实例化

thrift做为跨语言调用的方案有高效，支持语言较多，成熟等优点；代码侵入较强是其弱点。
下面记录以C++做服务器，C++,java和python做客户端的示例，这个和本人现在工作环境吻合，使用多线程长连接的socket来建立高效分布式系统的跨语言调用平台。遗憾的是目前版本(0.7.0)的C语言还不支持Compact协议，导致在现在的环境中nginx c mole调用thrift要使用binary协议。thrift开发团队似乎对C语言不太感冒。
1.定义idl文件acsuser.thrift

1 struct User{
2 1: string uid,
3 2: string uname,
4 3: bool usex,
5 4: i16 uage,
6 }
7 service UserService{
8 void add(1: User u),
9 User get(1: string uid),
10 }

2.生成c++,java和python代码框架
1 thrift -r --gen cpp acsuser.thrift
2 thrift -r --gen java acsuser.thrift
3 thrift -r --gen py acsuser.thrift

这时生成子目录gen-cpp,gen-java,gen-py
3.生成C++服务端代码
cp gen-cpp/UserService_server.skeleton.cpp UserServer.cpp
修改UserServer.cpp

1 #include "UserService.h"
2 #include <config.h>
3 //#include <protocol/TBinaryProtocol.h>
4 #include <protocol/TCompactProtocol.h>
5 #include <server/TSimpleServer.h>
6 #include <transport/TServerSocket.h>
7 #include <transport/TBufferTransports.h>
8 #include <concurrency/ThreadManager.h>
9 #include <concurrency/PosixThreadFactory.h>
10 #include <server/TThreadPoolServer.h>
11 #include <server/TThreadedServer.h>
12
13 using namespace ::apache::thrift;
14 using namespace ::apache::thrift::protocol;
15 using namespace ::apache::thrift::transport;
16 using namespace ::apache::thrift::server;
17 using namespace ::apache::thrift::concurrency;
18
19 using boost::shared_ptr;
20
21 class UserServiceHandler : virtual public UserServiceIf {
22 public:
23 UserServiceHandler() {
24 // Your initialization goes here
25 }
26
27 void add(const User& u) {
28 // Your implementation goes here
29 printf("uid=%s uname=%s usex=%d uage=%d\n", u.uid.c_str(), u.uname.c_str(), u.usex, u.uage);
30 }
31
32 void get(User& _return, const std::string& uid) {
33 // Your implementation goes here
34 _return.uid = "leo1";
35 _return.uname = "yueyue";
36 _return.usex = 1;
37 _return.uage = 3;
38 printf("uid=%s uname=%s usex=%d uage=%d\n", _return.uid.c_str(), _return.uname.c_str(), _return.usex, _return.uage);
39 }
40
41 };
42
43 int main(int argc, char **argv) {
44 shared_ptr<UserServiceHandler> handler(new UserServiceHandler());
45 shared_ptr<TProcessor> processor(new UserServiceProcessor(handler));
46 shared_ptr<TProtocolFactory> protocolFactory(new TCompactProtocolFactory());
47 shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
48 shared_ptr<TServerTransport> serverTransport(new TServerSocket(9090));
49
50 shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(10);
51 shared_ptr<PosixThreadFactory> threadFactory = shared_ptr<PosixThreadFactory>(new PosixThreadFactory());
52 threadManager->threadFactory(threadFactory);
53 threadManager->start();
54 printf("start user server...\n");
55
56 TThreadPoolServer server(processor, serverTransport, transportFactory, protocolFactory, threadManager);
57 server.serve();
58 return 0;
59 }

注意这段代码使用TCompactProtocol，需要#include <config.h>
另外这个是Blocking的多线程服务器
4.生成C++的client文件UserClient.cpp

1 #include "UserService.h"
2 #include <config.h>
3 #include <transport/TSocket.h>
4 #include <transport/TBufferTransports.h>
5 #include <protocol/TCompactProtocol.h>
6
7 using namespace apache::thrift;
8 using namespace apache::thrift::protocol;
9 using namespace apache::thrift::transport;
10
11 using boost::shared_ptr;
12
13 int main(int argc, char **argv) {
14 boost::shared_ptr<TSocket> socket(new TSocket("localhost", 9090));
15 boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
16 boost::shared_ptr<TProtocol> protocol(new TCompactProtocol(transport));
17
18 transport->open();
19
20 User u;
21 u.uid = "leo";
22 u.uname = "yueyue";
23 u.usex = 1;
24 u.uage = 3;
25
26 UserServiceClient client(protocol);
27 client.add(u);
28
29 User u1;
30 client.get(u1,"lll");
31
32 transport->close();
33 printf("uid=%s uname=%s usex=%d uage=%d\n", u1.uid.c_str(), u1.uname.c_str(), u1.usex, u1.uage);
34 return 0;
35 }

5.生成Makefile

1 BOOST_DIR = /usr/local/include/boost/
2 THRIFT_DIR = /usr/local/include/thrift
3 LIB_DIR = /usr/local/lib
4 GEN_SRC = ./gen-cpp/acsuser_types.cpp ./gen-cpp/acsuser_constants.cpp ./gen-cpp/UserService.cpp
5 default: server client
6 server: UserServer.cpp
7 g++ -g -o UserServer -I${THRIFT_DIR} -I${BOOST_DIR} -I./gen-cpp -L${LIB_DIR} -lthrift UserServer.cpp ${GEN_SRC}
8 client: UserClient.cpp
9 g++ -g -o UserClient -lm -pthread -lz -lrt -lssl -I${THRIFT_DIR} -I${BOOST_DIR} -I./gen-cpp -L${LIB_DIR} -lthrift UserClient.cpp ${GEN_SRC}
10 clean:
11 $(RM) -r UserServer UserClient

6.启动c++ server

1 ./UserServer

7.测试c++ client

1 ./UserClient

8.写java client文件UserClient.java

1 import org.apache.thrift.TException;
2 import org.apache.thrift.protocol.TCompactProtocol;
3 import org.apache.thrift.protocol.TProtocol;
4 import org.apache.thrift.transport.TFramedTransport;
5 import org.apache.thrift.transport.TNonblockingSocket;
6 import org.apache.thrift.transport.TSocket;
7 import org.apache.thrift.transport.TTransport;
8 import org.apache.thrift.transport.TTransportException;
9
10 //import UserService.Client;
11
12 public class UserClient {
13 private void start() {
14 try {
15 TTransport socket = new TSocket("localhost", 9090);
16 //TTransport transport = new TFramedTransport(socket);
17 TProtocol protocol = new TCompactProtocol(socket);
18
19 UserService.Client client = new UserService.Client(protocol);
20 socket.open();
21 System.out.println(client.get("lll"));
22
23 User u = new User();
24 u.uid="leojava";
25 u.uname="yueyue";
26 u.usex=true;
27 u.uage=3;
28 client.add(u);
29 socket.close();
30
31 } catch (TTransportException e) {
32 e.printStackTrace();
33 } catch (TException e) {
34 e.printStackTrace();
35 }
36 }
37
38 public static void main(String[] args) {
39 UserClient c = new UserClient();
40 c.start();
41
42 }
43 }

编译和运行java client
1 javac -classpath /usr/local/lib/libthrift-0.7.0.jar:/usr/local/lib/log4j-1.2.14.jar:/usr/local/lib/commons-logging-1.1.1.jar:/usr/local/lib/slf4j-api-1.5.8.jar UserClient.java ./gen-java/*.java
2 java -classpath .:./gen-java:/usr/local/lib/libthrift-0.7.0.jar:/usr/local/lib/log4j-1.2.14.jar:/usr/local/lib/commons-logging-1.1.1.jar:/usr/local/lib/slf4j-api-1.5.8.jar:/usr/local/lib/slf4j-log4j12-1.5.8.jar UserClient

9.写Python client文件PythonClient.py

1 #!/usr/bin/env python
2 import sys
3 sys.path.append('./gen-py')
4 from acsuser import UserService
5 from acsuser.ttypes import *
6 from thrift import Thrift
7 from thrift.transport import TSocket
8 from thrift.transport import TTransport
9 from thrift.protocol import TCompactProtocol
10
11 # Make socket
12 transport = TSocket.TSocket('localhost', 9090)
13 # Buffering is critical. Raw sockets are very slow
14 transport = TTransport.TBufferedTransport(transport)
15 # Wrap in a protocol
16 protocol = TCompactProtocol.TCompactProtocol(transport)
17 # Create a client to use the protocol encoder
18 client = UserService.Client(protocol)
19 # Connect!
20 transport.open()
21 # Call Server services
22 u = client.get('lll')
23 print 'uid=%s uname=%s usex=%d u.uage=%d' %(u.uid,u.uname,u.usex,u.uage)
24
25 u1 = User()
26 u1.uid='leo'
27 u1.uname='yueyue'
28 u1.usex=1
29 u1.uage=3
30 client.add(u1)

执行python client代码
1 chmod 777 PythonClient.py
2 ./PythonClient.py

❻ 享学课堂浅谈Python序列内建函数都有哪些

1、Python类型操作符和内建函数总结
表4.5列出了所有操作符和内建函数，其中操作符顺序是按优先级从高到低排列的。同一种灰度的操作符拥有同样的优先级。注意在operator模块中有这些（和绝大多数Python)操作符相应的同功能的函数可供使用。

表4.5 标准类型操作符和内建函数

操作符/函数

描 述

结 果a

字符串表示

``

对象的字符串表示

str

内建函数

cmp(obj1, obj2)

比较两个对象

int

repr(obj)

对象的字符串表示

str

str(obj)

对象的字符串表示

str

type(obj)

检测对象的类型

type

值比较

<

小于

bool

>

大于

bool

<=

小于或等于

bool

>=

大于或等于

bool

==

等于

bool

!=

不等于

bool

<>

不等于

bool

对象比较

is

是

bool

is not

不是

bool

布尔操作符

not

逻辑反

bool

and

逻辑与

bool

or

逻辑或

bool

2、Python数值类型操作符和内建函数

一、工厂函数
数值工厂函数总结类（工厂函数） 操作
bool(obj) b 返回obj对象的布尔值，也就是 obj.__nonzero__()方法的返回值。
int(obj, base=10) 返回一个字符串或数值对象的整数表 示， 类似string.atoi();
从Python 1.6起， 引入了可选的进制参数。
long(obj, base=10) 返回一个字符或数据对象的长整数表 示，类似string.atol(),
从Python1.6起， 引入了可选的进制参数 float(obj) ，
返回一个字符串或数据对象的浮点数 表示，类似string.atof()。
complex(str) or返回一个字符串的复数表示，或 者根据给定的实数，
complex(real, imag=0.0) （及一个可选 的虚数部分）生成一个复数对象。

二、内建函数
1、分类
Python 有五个运算内建函数用于数值运算：
abs(num), coerce(num1,num2), divmod(num1,num2), pow(num1,num2,mod=1)和 round(flt,ndig=0)
其中abs()返回给定参数的绝对值。如果参数是一个复数， 那么就返回math.sqrt(num.real2 + num.imag2).
coerce()是一个数据类型转换函数，不过它的行为更像一个运算符.数coerce（）为程序员提供了不依赖Python 解释器，而是自定义两个数值类型转换的方法。对一种新创建的数值类型来说， 这个特性非常有用.函数coerce()仅返回一个包含类型转换完毕的两个数值元素的元组.
divmod()内建函数把除法和取余运算结合起来, 返回一个包含商和余数的元组.对整数来说，它的返回值就是地板除和取余操作的结果.对浮点数来说，返回的商部分是math.floor(num1/num2)，对复数来说，商部分是ath.floor((num1/num2).real).
pow()它和双星号 （**）运算符都可以进行指数运算.不过二者的区别并不仅仅在于一个是运算符，一个是内建函数.在Python 1.5 之前，并没有 ** 运算符,内建函数pow()还接受第三个可选的参数，一个余数参数.如果有这个参数的， pow() 先进行指数运算，然后将运算结果和第三个参数进行取余运算.这个特性主要用于密码运算，并且比 pow(x,y) % z 性能更好， 这是因为这个函数的实现类似于C 函数pow(x,y,z).
round()用于对浮点数进行四舍五入运算。它有一个可选的小数位数参数.如果不提供小数位参数， 它返回与第一个参数最接近的整数（但仍然是浮点类型）.第二个参数告诉round 函数将结果精确到小数点后指定位数.

2、函数int()/round()/math.floor()它们之间的不同之处：
函数 int()直接截去小数部分.（返回值为整数）
函数 floor()得到最接近原数但小于原数的整数.（返回值为浮点数）
函数 round() 得到最接近原数的整数.（返回值为浮点数）

3、进制转换函数:
返回字符串表示的8 进制和16 进制整数,它们分别是内建函数：
oct()和 hex(). oct(255)='0377'/hex(255)='0xff'
函数chr()接受一个单字节整数值(0到255)，返回一个字符串(ASCII)，其值为对应的字符.chr(97)='a'
函数ord()则相反，它接受一个字符(ASCII 或 Unicode)，返回其对应的整数值.ord('A')=65
3、Python字符串函数
(一)标准类型操作符和标准内建函数
1)、标准类型操作符
>,<,>=,<=,==,!=,<>对象值得比较
注：做比较时字符串是按ASCII值的大小来比较的
is 对象身份比较
and,or,not 布尔类型
2）标准内建函数
type(obj)
cmp(obj1,obj2)
str(obj)和repr(obj) 或反引号运算符(``) 可以方便的以字符串的方式获取对象的
内容、类型、数值属性等信息。str()函数得到的字符串可读性好， 而repr()函数得到的字符
串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的
isinstance(obj,type) 判断对象的类型
(二)序列操作
1、序列操作
字符串属于序列对象，可以使用所有序列的操作和函数
切片 [] [:] [::]
简单总结：
*索引（S[i])获取特定偏移的元素。
——第一个元素偏移为0
——（S[0])获取第一个元素。
——负偏移索引意味着从最后或右边反向进行计数
——（S[-2])获取倒数第二个元素（就像S[len(s)-2]一样
*分片[S[i:j]提取对应的部分作为一个序列
——右边界不包含在内
——分片的边界默认为0和序列的长度，如果没有给出的话S[:]
——（S[1:3])获取了从偏移为1，直到但不包括偏移为3的元素
——（S[1:])获取从偏移为1到末尾之间的元素
——（S[:3])获取从偏移为0直到但不包括偏移为3的元素
——（S[:-1])获取从偏移为0直到但不包括最后一个元素之间的元素
——（S[:])获取从偏移为0到末尾之间的元素,这有效地实现了顶层S拷贝
拷贝了一个相同值，但是是不同内存区域的对象。对象字符串这样不可变的对象不是很有用，但是对于可以实地修改的对象来说很有用。
比如列表。
扩展分片：第三个限制值 【步进】
完整形式：X[I:J:K]:这标识索引X对象的元素，从偏移为I直到J-1，每隔K元素索引一次。第三个限制值，K，默认为1
实例

Python Code

1
2
3
4
5

>>> S='abcdefghijk'
>>> S[1:10]
'bcdefghij'
>>> S[1:10:2]
'bdfhj

也可以使用负数作为步进。
分片表达式

Python Code

1
2

>>> "hello"[::-1]
'olleh'

通过负数步进，两个边界的意义实际上进行了反转。
3、成员操作符 in ，not in
返回布尔值True 或False
可以使用string模块来判断输入字符的合法性，可见成品中的idcheck.py
4、字符串连接
+ 连接字符串 ‘name’+' '+'jin'
字符串格式化 '%s %s' % ('name','jin')
join()方法 ' '.join(('name','jin')) ' '.join(['name','jin'])
5、删除清空字符串
del aString
aString=''
(三)、序列函数
序列类型函数
len(str) 返回字串的长度
enumerate(iter):接受一个可迭代对象作为参数，返回一个enumerate
max(str)/min(str):max()和min()函数对其他的序列类型可能更有用,但对于string类型它们能很好地运行,返回最大或者最小的字符(按照ASCII 码值排列),
zip([it0, it1,... itN]) 返回一个列表，其第一个元素是it0,it1,...这些元素的第一个元素组成的一个元组，第二个...,类推.
reversed(seq)c 接受一个序列作为参数,返回一个以逆序访问的迭代器(PEP 322)
sorted(iter,func=None,key=None,reverse=False) 接受一个可迭代对象作为参数，返回一个有序的列表;可选参数func,key 和reverse 的含义跟list.sort()内建函数的参数含义一样.
注意：
sorted等需要在原处修改的函数无法用在字符串对象，但可以产生新的对象
sum处理的对象是数字，不能用在字符串
>>> sorted(s)
['a', 'e', 'e', 'g', 'g', 'g', 'o']
(四)只适合于字符串类型的函数
1)raw_input()函数
内建的raw_input()函数使用给定字符串提示用户输入并将这个输入返回，下面是一个使
用raw_input()的例子:
>>> user_input = raw_input("Enter your name: ")
>>> prin user_input
2)str() and unicode()
str()和unicode()函数都是工厂函数，就是说产生所对应的类型的对象.它们接受一个任
意类型的对象，然后创建该对象的可打印的或者Unicode 的字符串表示. 它们和basestring 都
可以作为参数传给isinstance()函数来判断一个对象的类型
3)chr(), unichr(), and ord()
chr()函数用一个范围在range(256)内的(就是0 到255)整数做参数,返回一个对应的字符.unichr()跟它一样，只不过返回的是Unicode 字符
ord()函数是chr()函数(对于8 位的ASCII 字符串)或unichr()函数(对于Unicode 对象)
的配对函数,它以一个字符(长度为1 的字符串)作为参数,返回对应的ASCII 数值，或者Unicode
数值，如果所给的Unicode 字符超出了你的Python 定义范围,则会引发一个TypeError 的异常
(五)、只适用于字符串的操作符
1、格式化操作符 %
字符串格式化符号
格式化字符 转换方式
%c 转换成字符(ASCII 码值，或者长度为一的字符串)
%ra 优先用repr()函数进行字符串转换
%s 优先用str()函数进行字符串转换
%d / %i 转成有符号十进制数
%ub 转成无符号十进制数
%ob 转成无符号八进制数
%xb/%Xb (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大
小写)
%e/%E 转成科学计数法(e/E 控制输出e/E)
%f/%F 转成浮点数(小数部分自然截断)
%g/%G %e 和%f/%E 和%F 的简写
%% 输出%
格式化操作符辅助指令
符号 作用
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
<sp> 在正数前面显示空格
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于
用的是'x'还是'X')
0 显示的数字前面填充‘0’而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
2、字符串模板: 更简单的替代品
由于新式的字符串Template 对象的引进使得string 模块又重新活了过来，Template 对象
有两个方法,substitute()和safe_substitute().前者更为严谨,在key 缺少的情况下它会报一
个KeyError 的异常出来，而后者在缺少key 时，直接原封不动的把字符串显示出
3、原始字符串操作符( r/R )
字符串抑制转义r'带特殊符号的字串'
myfile=open(r'C:\new\text.data','w')
4、Unicode 字符串操作符( u/U )
u'abc' U+0061 U+0062 U+0063
u'\u1234' U+1234
u'abc\u1234\n' U+0061 U+0062 U+0063 U+1234 U+0012

(六)字符串对象的方法：
1、删减
T2.lstrip() 移除字符串前面字符（默认空格），返回字符串
T2.rstrip() 移除字符串后面字符（默认空格），返回字符串
T2.strip() 移除字符串前后面空格，返回字符串 默认空格，可以其他字符 S.strip('"')
2、切割
partition(sep),
rpartition(sep),
splitlines([keepends]),#把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符
split([sep [,maxsplit]]),#以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
rsplit([sep[,maxsplit]]) #从右到左切割
备注：
partition()函数族是2.5版本新增的方法。它接受一个字符串参数，并返回一个3个元素的 tuple 对象。
如果sep没出现在母串中，返回值是 (sep, ‘’, ‘’)；
否则，返回值的第一个元素是 sep 左端的部分，第二个元素是 sep 自身，第三个元素是 sep 右端的部分。
>>> S.partition(';')
('', ';', ' generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n')
参数 maxsplit 是分切的次数，即最大的分切次数，所以返回值最多有 maxsplit+1 个元素。
s.split() 和 s.split(‘ ‘)的返回值不尽相同
>>> ' hello world!'.split()
['hello', 'world!']
>>> ' hello world!'.split(' ')
['', '', 'hello', '', '', 'world!']
>>> S.split('\n',3)
['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n']
超过最大切割个数后面的全部为一个元素
按行切割
>>> S
'; generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n'
>>> S.splitlines()
['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2', 'nameserver 178.79.131.110', 'nameserver 202.96.199.133']

产生差异的原因在于当忽略 sep 参数或sep参数为 None 时与明确给 sep 赋予字符串值时 split() 采用两种不同的算法。
对于前者，split() 先去除字符串两端的空白符，然后以任意长度的空白符串作为界定符分切字符串
即连续的空白符串被当作单一的空白符看待；
对于后者则认为两个连续的 sep 之间存在一个空字符串。因此对于空字符串（或空白符串），它们的返回值也是不同的：
>>> ''.split()
[]
>>> ''.split(' ')
['']
3、变形
lower(),#全部小写
upper(),#全部小写
capitalize(),#首字母大写
swapcase(),#大小写交换
title()#每个单词第一个大写,其他小写
备注
因为title() 函数并不去除字符串两端的空白符也不会把连续的空白符替换为一个空格，
所以建议使用string 模块中的capwords(s)函数，它能够去除两端的空白符，再将连续的空白符用一个空格代替。

Python Code

1
2
3
4

>>> ' hello world!'.title()
' Hello World!'
>>> string.capwords(' hello world!')
'Hello World!'

4、连接
join(seq)
join() 函数的高效率（相对于循环相加而言），使它成为最值得关注的字符串方法之一。
它的功用是将可迭代的字符串序列连接成一条长字符串，如：
>>> conf = {'host':'127.0.0.1',
... 'db':'spam',
... 'user':'sa',
... 'passwd':'eggs'}
>>> ';'.join("%s=%s"%(k, v) for k, v in conf.iteritems())
'passswd=eggs;db=spam;user=sa;host=127.0.0.1'
>>> S=''.join(T) #使用空字符串分割把字符列表转换为字符串
5、查找
count( sub[, start[, end]]),#计算substr在S中出现的次数
find( sub[, start[, end]]),#返回S中出现sub的第一个字母的标号，如果S中没有sub则返回-1。start和end作用就相当于在S[start:end]中搜索
index( substr[, start[, end]]),#与find()相同，只是在S中没有substr时，会返回一个运行时错误
rfind( sub[, start[,end]]),#返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号
rindex( sub[, start[, end]])
T2.find('ie') 字符串方法调用：搜索
find()----找到的第一个符合字符的index
rfind()-----找到最后一个符合的字符的index
备注：
find()函数族找不到时返回-1，index()函数族则抛出ValueError异常。
另，也可以用 in 和 not in 操作符来判断字符串中是否存在某个模板
6、替换
replace(old, new[,count]),#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
translate(table[,deletechars]) #使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉
备注：
replace()函数的 count 参数用以指定最大替换次数
translate() 的参数 table 可以由 string.maketrans(frm, to) 生成
translate() 对 unicode 对象的支持并不完备，建议不要使用
7、判定
isalnum(),#是否全是字母和数字，并至少有一个字符
isalpha(),是否全是字母，并至少有一个字符
isdigit(),是否全是数字，并至少有一个字符 ，如果是全数字返回True,否则返回False
islower(),#S中的字母是否全是小写
isupper(),#S中的字母是否是大写
isspace(),#是否全是空白字符，并至少有一个字符
istitle(),S是否是首字母大写的
startswith(prefix[, start[, end]]), #是否以prefix开头
endswith(suffix[,start[, end]]),#以suffix结尾
备注：
这些函数都比较简单，顾名知义。需要注意的是*with()函数族可以接受可选的 start, end 参数，善加利用，可以优化性能。
另，自 Py2.5 版本起，*with() 函数族的 prefix 参数可以接受 tuple 类型的实参，当实参中的某人元素能够匹配，即返回 True。
8、填充
字符串在输出时的对齐：
center(width[, fillchar]), 字符串中间对齐
ljust(width[, fillchar]), 字符串左对齐，不足部分用fillchar填充，默认的为空格
rjust(width[, fillchar]), 字符串右对齐，不足部分用fillchar填充，默认的为空格
zfill(width), 把字符串变成width长，并在右对齐，不足部分用0补足
expandtabs([tabsize])把字符串中的制表符（tab）转换为适当数量的空格。
fillchar 参数指定了用以填充的字符，默认为空格
zfill的z为zero的缩写,顾名思义,是以字符0进行填充，用于数值输出
expandtabs()的tabsize 参数默认为8。它的功能是把字符串中的制表符（tab）转换为适当数量的空格。
9、编码
encode([encoding[,errors]]),
decode([encoding[,errors]])
这是一对互逆操作的方法，用以编码和解码字符串。因为str是平台相关的，它使用的内码依赖于操作系统环境，
而unicode是平台无关的，是Python内部的字符串存储

❼ python可以用类的实例作为List元素么

可以啊

以下代码调试通过：

classTeam:＃类的定义
team_name=""
team_years=0

def__init__(self,name,team_years):
self.team_name=name
self.team_years=team_years
self.wlp=[]

defaddWLP(self,x):＃类方法
self.wlp.append(x)


_l=[]＃定义列表
foriinrange(19):
_d=Team("name"+str(i),i)＃生成类的实例
_l.append(_d)＃每个实例为一个列表元素，挂在最后面
print(_l)


forjin_l:
print(j.__dict__)

运行效果：

❽ python 类实例化

1、python的类中，以__(两个下划线)开头但不以__结束的就是私有的变量或者函数,私有函数和变量不能在class外调用到。
class test:
def __init__(self, num):
self.__num = num
privateTest = test(100)
privateTest.__num#会报错
当然也有办法调到，只是不建议那样做。
2、第一个class se()中的 变量s，是一个类变量，是class se的变量，类变量可以被类本身访问，如se.s，也可以被各个对象访问，而且由于是存在class里的所以值唯一，有点像C++里的static。
但是如果有某一个对象也创建了一个叫s的变量 覆盖了类变量，那么那个self.s就是对象的属性,而不会调到类变量。
你可以运行试试
# -*- coding: cp936 -*-
class A:
name = []
def __init__(self, name):
self.name.append(name)

def nameMyself(self, name):
self.name = [name]
print 'my name is',self.name, 'and class A1name is :', A.name

def test(self):
print "my name is", self.name
obj = A("num0")
obj1 = A("num1")
print "obj1`name", obj1.name#对象访问类变量name
print "class A`name", A.name#class自己访问类变量name
obj1.test()#此时还是访问的类变量name
obj1.nameMyself('aid')#给自己起个名覆盖类变量的name
obj1.test()#对于obj1来说只能访问自己的name了
print "class A`name", A.name#类变量依然存在

❾ 在Python中怎么把class类转成list类

你需要自定义函数。

或者使用__list__，这样就可以使用内置的list函数了。

classA:
def__init__():
self.a=1
self.b=2

defto_list():
"""需要你自定义函数行为"""
return[self.a,self.b]

def__list__():
"""需要你自定义函数行为"""
return[self.a,self.b]


a=A()
lst1=a.to_list()
lst2=list(a)#调用__list__

别的可以直接调用list函数的都是底层实现了__list__或者做了别的实现，你自己的类需要你自己实现。

❿ python 类 __init__ 函数 实例化 list 重复

valueset=10

classchromo:

'''染色体'''

def__init__(self):
self.list=[]
foriinrange(len(ann.F_list)):
self.list.append(ann.uniform(-valueset,valueset))

defmutate(self):
'''变异'''
R=ann.choice(range(len(self.list)))
self.list[R]=ann.uniform(-valueset,valueset)
return

defcrossover(self,annothC):
'''交叉'''
R=ann.choice(range(len(self.list)))
temp=self.list[0:R]+annothC.list[R:len(self.list)]
annothC.list=self.list[R:len(self.list)]+annothC.list[0:R]
self.list=temp

?