我们在python编程中，有的时候需要写标题，但是代码格式为字符串。这时就要用到python中的title函数，它可以将首字母大写，将字符串转换为标题格式。
 
1、title函数
 
python中字符串函数，返回’标题化‘的字符串，就是单词的开头为大写，其余为小写
 
2、语法
 
string.title()
 
3、使用实例
 
在这里插入代码片
 
str=' tHe wOrLDwidE Web '

 

str.title()

 

str.title().strip()
 
输出
 
' The Worldwide Web '

 

'The Worldwide Web'
 
以上就是python中title函数的介绍，大家如果需要将字符串转换为标题格式，可以使用title函数哦~

 
在更新模型和序列化程序之后，我无法将新文章保存到数据库中。我一直得到“'title'是这个函数的无效关键字参数。”
 
我正在研究Postgres10、Python3.6、Django2.0和drf3.8.2。在
 
我丢了我的数据库几次，但错误仍然存在。拜托，我需要你的帮助。提前谢谢。在
 
这是我的旧模型的副本class Article(models.Model):
 
title = models.CharField(max_length=200, blank=False)
 
slug = models.SlugField(max_length=250, unique_for_date='created')
 
body = models.TextField()
 
image_url = models.URLField(max_length=255)
 
author = models.ForeignKey(User, on_delete=models.CASCADE)
 
created = models.DateTimeField(auto_now_add = True)
 
published = models.DateTimeField(auto_now=True)
 
updated = models.DateTimeField(auto_now=True)
 
country = models.ForeignKey(Country, on_delete=models.CASCADE)
 
categories = models.ManyToManyField(Category, default=1)
 
# categories = ArrayField(models.IntegerField(), blank=False)
 
entities = models.ManyToManyField(Entity, default=1)
 
# entities = ArrayField(models.CharField(max_length=200),
 
blank=True)
 
summary = models.TextField(blank=True)
 
is_published = models.BooleanField(default=False)
 
is_curated = models.BooleanField(default=False)
 
class Meta:
 
ordering = ('-created',)
 
def __str__(self):
 
return self.title
 
def save(self, *args, **kwargs):
 
self.slug = slugify(self.title)
 
super(Article, self).save(*args, **kwargs)
 
我的新(更新)型号：
 
^{pr2}$
 
我的序列化程序：class CreateArticleSerializer(serializers.ModelSerializer):
 
author = UserSerializer(read_only=True, required=False)
 
country = CountrySerializer(read_only=True)
 
class Meta:
 
model = Article
 
fields = ("id", "title", "body", "image_url", "country",
 
"keypoint1", "keypoint2", "keypoint3", "keypoint4",
 
"category", "entities", "author", "created", "updated",
 
"published", "is_published")
 
read_only_fields = ("id", "created", "slug")
 
def create(self, validated_data):
 
entities_relations = validated_data.pop('entities', None)
 
entity_instance = Entity.objects.create(**validated_data)
 
entity_instance.posts = entities_relations
 
article = Article.objects.create(entities=entity_instance,
 
**validated_data)
 
return article
 
以及我的create post视图：class ArticleAPIView(generics.CreateAPIView):
 
queryset = Article.objects.all()
 
serializer_class = CreateArticleSerializer
 
permission_classes = (IsAuthenticatedOrReadOnly,)
 
#Create a new post
 
def post(self, request, format=None):
 
data_map = {
 
'title': request.data.get('title'),
 
'body': request.data.get('body'),
 
'image_url': request.data.get('imageUrl'),
 
'keypoint1': request.data.get('keyPoint1'),
 
'keypoint2': request.data.get('keyPoint2'),
 
'keypoint3': request.data.get('keyPoint3'),
 
'keypoint4': request.data.get('keyPoint4'),
 
}
 
serializer = CreateArticleSerializer(data=data_map,context=
 
{'request': request})
 
if serializer.is_valid():
 
serializer.save(author=self.request.user)
 
post_id = serializer.instance.id
 
post = get_object_or_404(Article, pk=post_id)
 
return Response((jsend.success({'post':
 
serializer.data})), status=status.HTTP_201_CREATED)
 
else:
 
return Response((jsend.fail(serializer.errors)),
 
status=status.HTTP_400_BAD_REQUEST)

 

 
本文最初发表于赖勇浩(恋花蝶)的博客(http://blog.csdn.net/lanphaday)，如蒙转载，敬请保留全文完整，切勿去除本声明和作者信息。
 
在编程中，几乎90% 以上的代码都是关于整数或字符串操作，所以与整数一样，Python 的字符串实现也使用了许多拿优化技术，使得字符串的性能达到极致。与 C++ 标准库(STL)中的 std::string 不同，python 字符串集合了许多字符串相关的算法，以方法成员的方式提供接口，使用起来非常方便。 字符串方法大约有几十个，这些方法可以分为如下几类(根据 manuals 整理)：
 
类型 方法 注解 填充
 
center(width[, fillchar]) ,
 
ljust(width[, fillchar]),
 
rjust(width[, fillchar]),
 
zfill(width),
 
expandtabs([tabsize])
 
l
 
fillchar 参数指定了用以填充的字符，默认为空格
 
l
 
顾名思义，zfill()即是以字符0进行填充，在输出数值时比较常用
 
l
 
expandtabs()的tabsize 参数默认为8。它的功能是把字符串中的制表符(tab)转换为适当数量的空格。
 
删减
 
strip([chars]),
 
lstrip([chars]),
 
rstrip([chars])
 
*strip()函数族用以去除字符串两端的空白符，空白符由string.whitespace常量定义。 变形
 
lower(),
 
upper(),
 
capitalize(),
 
swapcase(),
 
title()
 
title()函数是比较特别的，它的功能是将每一个单词的首字母大写，并将单词中的非首字母转换为小写(英文文章的标题通常是这种格式)。
 
>>> 'hello wORld!'.title()
 
'Hello World!'
 
因为title() 函数并不去除字符串两端的空白符也不会把连续的空白符替换为一个空格，所以建议使用string 模块中的capwords(s)函数，它能够去除两端的空白符，再将连续的空白符用一个空格代替。
 
>>> ' hello   world!'.title()
 
' Hello   World!'
 
>>> string.capwords(' hello   world!')
 
'Hello World!'
 
分切
 
partition(sep),
 
rpartition(sep),
 
splitlines([keepends]),
 
split([sep [,maxsplit]]),
 
rsplit([sep[,maxsplit]])
 
l
 
*partition()函数族是2.5版本新增的方法。它接受一个字符串参数，并返回一个3个元素的 tuple 对象。如果sep没出现在母串中，返回值是 (sep, ‘’, ‘’)；否则，返回值的第一个元素是 sep 左端的部分，第二个元素是 sep 自身，第三个元素是 sep 右端的部分。
 
l
 
参数 maxsplit 是分切的次数，即最大的分切次数，所以返回值最多有 maxsplit+1 个元素。
 
l
 
s.split() 和 s.split(‘ ‘)的返回值不尽相同
 
>>> ' hello   world!'.split()
 
['hello', 'world!']
 
>>> ' hello   world!'.split(' ')
 
['', '', 'hello', '', '', 'world!']
 
产生差异的原因在于当忽略 sep 参数或sep参数为 None 时与明确给 sep 赋予字符串值时 split() 采用两种不同的算法。对于前者，split() 先去除字符串两端的空白符，然后以任意长度的空白符串作为界定符分切字符串(即连续的空白符串被当作单一的空白符看待)；对于后者则认为两个连续的 sep 之间存在一个空字符串。因此对于空字符串(或空白符串)，它们的返回值也是不同的：
 
>>> ''.split()
 
[]
 
>>> ''.split(' ')
 
['']
 
连接 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'
 
判定
 
isalnum(),
 
isalpha(),
 
isdigit(),
 
islower(),
 
isupper(),
 
isspace(),
 
istitle(),
 
startswith(prefix[, start[, end]]),
 
endswith(suffix[,start[, end]])
 
这些函数都比较简单，顾名知义。需要注意的是*with()函数族可以接受可选的 start, end 参数，善加利用，可以优化性能。
 
另，自 Py2.5 版本起，*with() 函数族的 prefix 参数可以接受 tuple 类型的实参，当实参中的某人元素能够匹配，即返回 True。
 
查找
 
count( sub[, start[, end]]),
 
find( sub[, start[, end]]),
 
index( sub[, start[, end]]),
 
rfind( sub[, start[,end]]),
 
rindex( sub[, start[, end]])
 
find()函数族找不到时返回-1，index()函数族则抛出ValueError异常
 
另，也可以用 in 和 not in 操作符来判断字符串中是否存在某个模板。
 
替换
 
replace(old, new[,count]),
 
translate(table[,deletechars])
 
l
 
replace()函数的 count 参数用以指定最大替换次数
 
l
 
translate() 的参数 table 可以由 string.maketrans(frm, to) 生成
 
l
 
translate() 对 unicode 对象的支持并不完备，建议不要使用。
 
编码
 
encode([encoding[,errors]]),
 
decode([encoding[,errors]])
 
这是一对互逆操作的方法，用以编码和解码字符串。因为str是平台相关的，它使用的内码依赖于操作系统环境，而unicode是平台无关的，是Python内部的字符串存储方式。unicode可以通过编码(encode)成为特定编码的str，而str也可以通过解码(decode)成为unicode。

 
一、定义函数
 
形参：函数完成一项工作所需要的信息，在函数定义时完成
 
实参：调用函数时传递给函数的信息
 
二、传递实参
 
1.位置实参:每个实参都关联到函数定义中的一个形参
 
示例： def describe_pet(animal_type,pet_name):
 
print("My"+ animal_type+"'s is"+pet_name.title()+".")
 
describe_pet('hamster','harry')
 
2.关键字实参是传递给函数的名称-值对 (直接在实参中将名称和值关联起来，这样无需考虑函数调用中的实参顺序)
 
def describe_pet(animal_type,pet_name):
 
print("My"+ animal_type+"'s is"+pet_name.title()+".")
 
describe_pet(animal_type='hamster',pet_name='harry')
 
3.默认值：编写函数时，可给每个形参指定默认值。在调用函数时给形参指定了实参值时，python将使用指定实参值；否则，将使用形参的默认值。
 
def describe_pet(pet_name,animal_type='dog'):
 
print("My"+ animal_type+"'s is"+pet_name.title()+".")
 
调用式1: describe_pet('hamster') 使用形参默认值
 
调用式2: describe_pet(pet_name='harry',animal_type='hamster')
 
显示的给animal_type提供了实参，因此python忽略了形参的默认值
 
注意：使用默认值时，在形参列表中必须先列出没有默认值的形参，在列出有默认值得形参，这让python能正确解读位置实参
 
4.等效的函数调用：指定实参时可以使用位置方式，也可以使用关键字方式
 
def describe_pet(pet_name,animal_type='dog'):
 
print("My"+ animal_type+"'s is"+pet_name.title()+".")
 
#一条命为willie的小狗
 
describe_pet('willie')
 
describe_pet(pet_name='willie')
 
#一只名为Harry的仓鼠
 
describe_pet('harry','hamster') --位置实参
 
describe_pet(pet_name='harry',animal_type='hamster')--关键字实参
 
describe_pet(animal_type='hamster',pet_name='harry')
 
三、返回值： return语句将值返回到调用函数的代码行
 
1.返回简单的值
 
2.让实参变成可选的
 
def get_formatted_name(first_name,last_name,middle_name=''):ifmiddle_name:
 
full_name=first_name+' '+middle_name+' '+last_nameelse:
 
full_name=first_name+' '+last_name
 
reutn full_name
 
musician=get_formatted_name('zilong','zhou')
 
print(musician)
 
musician=get_formatted_name('xifeng','wang','lee')
 
print(musician)
 
为让中间名变成可选，可给形参middle_name一个默认值-空字符串,并在用户没有提供中间名时不使用这个实参
 
3.返回字典：函数可返回任何类型的值，包括列表和字典等较为复杂的数据结构
 
def build_person(first_name,last_name,age='')
 
person={'first_name':first_name,'last_name':last_name}
 
if age:
 
age=32
 
retun person
 
musician=build_person('yufang','ke',20)
 
print(musician)
 
4.将函数与while循环结合使用
 
def get_formatted_name(first_name,last_name)
 
full_name=first_name+' '+last_name
 
retun full_namewhile true:
 
print("please tell me your name|enter q to quit")
 
first_name=input("first name: ")if first_name == 'q':break;
 
last_name=input("last name: ")if last_name == 'q':break;
 
formatted_named=get_formatted_name(first_name,last_name)
 
print(formatted_named)
 
四、传递列表
 
1.在函数中修改列表：3D打印模型公司需要打印的设计存储在一个列表中，打印后移到另一个列表中
 
def print_models(unprinted_designs,completed_models):whileunprinted_designs:
 
current_design=unprinted_designs.pop()
 
completed_models.append(current_design)
 
def show_completed_models(completed_models):
 
print("the following models have been printed:")for completed_model incompleted_models：
 
print(completed_model)
 
unprinted_designs=['iphone case','robot pendant','dodecahedron']
 
completed_models=[]
 
print_models(unprinted_designs,completed_models)
 
show_completed_models(completed_models)
 
2.禁止函数列表修改(源代码参--在函数中修改列表)
 
print_models(unprinted_designs[:],completed_models)
 
unprinted_designs[:]获得列表unprinted_designs的副本，而不是列表unprinted_designs的本身，列表completed_models也将打印包含打印好的列表名称，但函数所做的修改不会影响到列表unprinted_designs
 
五、传递任意数量的实参
 
1.简单示例
 
制作比萨时需要接受很多配料，但无法预先确定顾客要多少配料，下面形参toppings能够接受任意多个实参
 
def make_pizza(*toppings):
 
print(toppings)
 
make_pizza('peper')
 
make_pizza('peper','extra cheese')
 
2.结合使用位置实参和任意数量实参
 
def make_pizza(size,*toppings):
 
print("making a"+str(size)+"-inch pizza with the following toppings:")for topping intoppings:
 
print("-"+topping)
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
3.使用任意数量的关键字实参：将函数编写能够接受任意数量的键-值对--调用语句提供多少就接受多少
 
build_profile()函数接受名和姓，同事还接受任意数量的关键字实参
 
def build_profile(first,last,**user_infos):
 
profile={}
 
profile['first_name']=first
 
profile['last_name']=lastfor key,value inuser_infos:
 
profile[key]=value
 
retun profile
 
user_profile=build_profile('albert','eisnst',location='princeton',field='physics')
 
print(user_profile)
 
六、将函数存储在模块中
 
函数的优点之一是使用它们可以和主程序分离；通过给函数指定描述性名称，可让主程序容易理解得多；你还可以将函数存储在称为模块的独立文件中，再将模块导入到主程序中。
 
import语句允许在当前运行的程序文件中使用模块中的代码
 
6.1导入整个模块
 
def make_pizza(size,*toppings):
 
print("making a"+str(size)+"-inch pizza with the following toppings: ")
 
for topping in toppings:
 
print("-"+topping)
 
接下来，我们在pizza.py文件所在目录创建另一个名为making_pizzas.py文件，这个文件导入刚创建的模块，再调用mkae_pizza()函数两次
 
import pizza
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
代码行import pizza让Python打开文件pizza.py，并将pizza.py文件中所有函数都复制到这个程序中
 
6.2 导入特定的函数
 
导入任意数量函数方法：from module import function_name;
 
对于前面making_pizzas.py示例，如果你只想导入使用的函数，代码将类似下面这样：
 
from pizza import make_pizza
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
6.3使用as给函数重命名
 
指定别名通用语法如下：
 
from module_name import function_name as fn
 
对于前面making_pizzas.py示例：
 
from pizza import make_pizza as mp
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
6.4使用as给模块指定别名
 
import pizza as p
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
给模块指定别名的通用方法如下：
 
import module_name as mn
 
6.5 导入模块中所有函数
 
使用*运算符可让python导入模块中的所有函数：
 
from pizza import *
 
make_pizza(16,'peper')
 
make_pizza(15,'peper','extra cheese')
 
6.6 函数编写指南
 
每个函数首先给函数指定描述性名称，且只在其中使用小写字母和下划线，并简要地阐述其功能注释，该注释应紧跟函数定义的后面