ฟังค์ชั่น Elegant Python เพื่อแปลง CamelCase เป็น snake_case?

ตัวอย่าง:

>>> convert('CamelCase')
'camel_case'

กรณีอูฐเพื่องูกรณี

import re

name = 'CamelCaseName'
name = re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()
print(name)  # camel_case_name

หากคุณทำหลายครั้งและข้างต้นช้ารวบรวม regex ล่วงหน้า:

pattern = re.compile(r'(?<!^)(?=[A-Z])')
name = pattern.sub('_', name).lower()

หากต้องการจัดการกรณีขั้นสูงมากเป็นพิเศษ (นี่จะไม่สามารถย้อนกลับได้อีกต่อไป):

def camel_to_snake(name):
  name = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
  return re.sub('([a-z0-9])([A-Z])', r'\1_\2', name).lower()

print(camel_to_snake('camel2_camel2_case'))  # camel2_camel2_case
print(camel_to_snake('getHTTPResponseCode'))  # get_http_response_code
print(camel_to_snake('HTTPResponseCodeXYZ'))  # http_response_code_xyz

กรณีงูกรณีอูฐ

name = 'snake_case_name'
name = ''.join(word.title() for word in name.split('_'))
print(name)  # SnakeCaseName

มีห้องสมุดผันในดัชนีแพคเกจที่สามารถจัดการสิ่งเหล่านี้ให้คุณได้ ในกรณีนี้คุณจะมองหาinflection.underscore():

>>> inflection.underscore('CamelCase')
'camel_case'

ฉันไม่รู้ว่าทำไมสิ่งเหล่านี้จึงซับซ้อน

สำหรับกรณีส่วนใหญ่การแสดงออกอย่างง่าย ๆ([A-Z]+)จะใช้กลอุบาย

>>> re.sub('([A-Z]+)', r'_\1','CamelCase').lower()
'_camel_case'  
>>> re.sub('([A-Z]+)', r'_\1','camelCase').lower()
'camel_case'
>>> re.sub('([A-Z]+)', r'_\1','camel2Case2').lower()
'camel2_case2'
>>> re.sub('([A-Z]+)', r'_\1','camelCamelCase').lower()
'camel_camel_case'
>>> re.sub('([A-Z]+)', r'_\1','getHTTPResponseCode').lower()
'get_httpresponse_code'

ในการเพิกเฉยต่ออักขระตัวแรกเพียงเพิ่มการมองหลัง (?!^)

>>> re.sub('(?!^)([A-Z]+)', r'_\1','CamelCase').lower()
'camel_case'
>>> re.sub('(?!^)([A-Z]+)', r'_\1','CamelCamelCase').lower()
'camel_camel_case'
>>> re.sub('(?!^)([A-Z]+)', r'_\1','Camel2Camel2Case').lower()
'camel2_camel2_case'
>>> re.sub('(?!^)([A-Z]+)', r'_\1','getHTTPResponseCode').lower()
'get_httpresponse_code'

หากคุณต้องการแยก ALLCaps ไปยัง all_caps และคาดหวังว่าตัวเลขในสตริงของคุณคุณยังไม่จำเป็นต้องทำการแยกกันสองครั้งเพียงแค่ใช้|การแสดงออกนี้((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))สามารถจัดการกับทุกสถานการณ์ในหนังสือ

>>> a = re.compile('((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))')
>>> a.sub(r'_\1', 'getHTTPResponseCode').lower()
'get_http_response_code'
>>> a.sub(r'_\1', 'get2HTTPResponseCode').lower()
'get2_http_response_code'
>>> a.sub(r'_\1', 'get2HTTPResponse123Code').lower()
'get2_http_response123_code'
>>> a.sub(r'_\1', 'HTTPResponseCode').lower()
'http_response_code'
>>> a.sub(r'_\1', 'HTTPResponseCodeXYZ').lower()
'http_response_code_xyz'

ทุกอย่างขึ้นอยู่กับสิ่งที่คุณต้องการดังนั้นใช้โซลูชันที่เหมาะสมกับความต้องการของคุณมากที่สุดเนื่องจากไม่ควรซับซ้อนเกินไป

Njoy!

stringcaseคือห้องสมุดของฉัน เช่น:

>>> from stringcase import pascalcase, snakecase
>>> snakecase('FooBarBaz')
'foo_bar_baz'
>>> pascalcase('foo_bar_baz')
'FooBarBaz'

โดยส่วนตัวแล้วฉันไม่แน่ใจว่าสิ่งใดที่ใช้นิพจน์ปกติในไพ ธ อนสามารถอธิบายได้ว่าสวยงาม คำตอบส่วนใหญ่ที่นี่เป็นเพียงการทำ "รหัสกอล์ฟ" พิมพ์ RE เทคนิค การเข้ารหัสที่หรูหราควรจะเข้าใจได้ง่าย

def to_snake_case(not_snake_case):
    final = ''
    for i in xrange(len(not_snake_case)):
        item = not_snake_case[i]
        if i < len(not_snake_case) - 1:
            next_char_will_be_underscored = (
                not_snake_case[i+1] == "_" or
                not_snake_case[i+1] == " " or
                not_snake_case[i+1].isupper()
            )
        if (item == " " or item == "_") and next_char_will_be_underscored:
            continue
        elif (item == " " or item == "_"):
            final += "_"
        elif item.isupper():
            final += "_"+item.lower()
        else:
            final += item
    if final[0] == "_":
        final = final[1:]
    return final

>>> to_snake_case("RegularExpressionsAreFunky")
'regular_expressions_are_funky'

>>> to_snake_case("RegularExpressionsAre Funky")
'regular_expressions_are_funky'

>>> to_snake_case("RegularExpressionsAre_Funky")
'regular_expressions_are_funky'

ฉันชอบที่จะหลีกเลี่ยงreถ้าเป็นไปได้:

def to_camelcase(s):
    return ''.join(['_' + c.lower() if c.isupper() else c for c in s]).lstrip('_')

>>> to_camelcase("ThisStringIsCamelCase")
'this_string_is_camel_case'

''.join('_'+c.lower() if c.isupper() else c for c in "DeathToCamelCase").strip('_')
re.sub("(.)([A-Z])", r'\1_\2', 'DeathToCamelCase').lower()

ฉันคิดว่าวิธีนี้ตรงไปตรงมามากกว่าคำตอบก่อนหน้า:

import re

def convert (camel_input):
    words = re.findall(r'[A-Z]?[a-z]+|[A-Z]{2,}(?=[A-Z][a-z]|\d|\W|$)|\d+', camel_input)
    return '_'.join(map(str.lower, words))


# Let's test it
test_strings = [
    'CamelCase',
    'camelCamelCase',
    'Camel2Camel2Case',
    'getHTTPResponseCode',
    'get200HTTPResponseCode',
    'getHTTP200ResponseCode',
    'HTTPResponseCode',
    'ResponseHTTP',
    'ResponseHTTP2',
    'Fun?!awesome',
    'Fun?!Awesome',
    '10CoolDudes',
    '20coolDudes'
]
for test_string in test_strings:
    print(convert(test_string))

ผลลัพธ์ใด:

camel_case
camel_camel_case
camel_2_camel_2_case
get_http_response_code
get_200_http_response_code
get_http_200_response_code
http_response_code
response_http
response_http_2
fun_awesome
fun_awesome
10_cool_dudes
20_cool_dudes

นิพจน์ทั่วไปตรงกับสามรูปแบบ:

1. [A-Z]?[a-z]+: ตัวอักษรตัวพิมพ์เล็กที่ต่อเนื่องกันซึ่งเป็นทางเลือกเริ่มต้นด้วยตัวอักษรตัวพิมพ์ใหญ่
2. [A-Z]{2,}(?=[A-Z][a-z]|\d|\W|$): อักษรตัวพิมพ์ใหญ่สองตัวหรือมากกว่าติดต่อกัน มันใช้ lookahead เพื่อแยกอักษรตัวพิมพ์ใหญ่ตัวสุดท้ายถ้าตามด้วยตัวอักษรตัวพิมพ์เล็ก
3. \d+: ตัวเลขที่ต่อเนื่องกัน

โดยการใช้งานre.findallเราจะได้รับรายชื่อ "คำศัพท์" แต่ละคำที่สามารถแปลงเป็นตัวพิมพ์เล็กและเชื่อมโยงกับขีดล่าง

ฉันไม่ทราบว่าทำไมใช้ทั้ง. sub () โทร? :) ฉันไม่ใช่กูรู regex แต่ฉันทำให้ฟังก์ชั่นนี้ง่ายขึ้นซึ่งเหมาะกับความต้องการของฉันฉันแค่ต้องการโซลูชันในการแปลง camelCasedVars จากคำขอ POST เป็น vars_with_underscore:

def myFunc(...):
  return re.sub('(.)([A-Z]{1})', r'\1_\2', "iTriedToWriteNicely").lower()

มันใช้งานไม่ได้กับชื่อเช่น getHTTPResponse เพราะฉันได้ยินมาว่ามันเป็นวิธีการตั้งชื่อที่ไม่ดี (น่าจะเหมือน getHttpResponse เห็นได้ชัดว่ามันจดจำรูปแบบนี้ได้ง่ายกว่า)

นี่คือทางออกของฉัน:

def un_camel(text):
    """ Converts a CamelCase name into an under_score name. 

        >>> un_camel('CamelCase')
        'camel_case'
        >>> un_camel('getHTTPResponseCode')
        'get_http_response_code'
    """
    result = []
    pos = 0
    while pos < len(text):
        if text[pos].isupper():
            if pos-1 > 0 and text[pos-1].islower() or pos-1 > 0 and \
            pos+1 < len(text) and text[pos+1].islower():
                result.append("_%s" % text[pos].lower())
            else:
                result.append(text[pos].lower())
        else:
            result.append(text[pos])
        pos += 1
    return "".join(result)

สนับสนุนกรณีมุมเหล่านั้นกล่าวถึงในความคิดเห็น ตัวอย่างเช่นมันจะแปลงgetHTTPResponseCodeเป็นget_http_response_codeอย่างที่ควรจะเป็น

เพื่อความสนุกของมัน

>>> def un_camel(input):
...     output = [input[0].lower()]
...     for c in input[1:]:
...             if c in ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'):
...                     output.append('_')
...                     output.append(c.lower())
...             else:
...                     output.append(c)
...     return str.join('', output)
...
>>> un_camel("camel_case")
'camel_case'
>>> un_camel("CamelCase")
'camel_case'

หรือมากกว่าเพื่อความสนุกของมัน:

>>> un_camel = lambda i: i[0].lower() + str.join('', ("_" + c.lower() if c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" else c for c in i[1:]))
>>> un_camel("camel_case")
'camel_case'
>>> un_camel("CamelCase")
'camel_case'

การใช้ regexes อาจสั้นที่สุด แต่วิธีนี้สามารถอ่านได้ง่ายขึ้น:

def to_snake_case(s):
    snake = "".join(["_"+c.lower() if c.isupper() else c for c in s])
    return snake[1:] if snake.startswith("_") else snake

วิธีการที่ซับซ้อนมากมาย ... เพียงแค่ค้นหากลุ่ม "Titled" ทั้งหมดและเข้าร่วมตัวแปรที่ต่ำกว่าพร้อมขีดล่าง

>>> import re
>>> def camel_to_snake(string):
...     groups = re.findall('([A-z0-9][a-z]*)', string)
...     return '_'.join([i.lower() for i in groups])
...
>>> camel_to_snake('ABCPingPongByTheWay2KWhereIsOurBorderlands3???')
'a_b_c_ping_pong_by_the_way_2_k_where_is_our_borderlands_3'

หากคุณไม่ต้องการสร้างตัวเลขเช่นตัวละครตัวแรกของกลุ่มหรือกลุ่มแยกคุณสามารถใช้([A-z][a-z0-9]*)หน้ากาก

ไม่ได้อยู่ในไลบรารีมาตรฐาน แต่ฉันพบสคริปต์นี้ที่ดูเหมือนจะมีฟังก์ชันที่คุณต้องการ

นี่ไม่ใช่วิธีที่สง่างามคือการใช้งาน 'สถานะต่ำ' อย่างง่ายของเครื่องสถานะเรียบง่าย (เครื่องสถานะบิตฟิลด์) อาจเป็นโหมดต่อต้าน pythonic ส่วนใหญ่ในการแก้ไขปัญหานี้อย่างไรก็ตามโมดูลใหม่ยังใช้เครื่องรัฐที่ซับซ้อนเกินไป งานดังนั้นฉันคิดว่านี่เป็นทางออกที่ดี

def splitSymbol(s):
    si, ci, state = 0, 0, 0 # start_index, current_index 
    '''
        state bits:
        0: no yields
        1: lower yields
        2: lower yields - 1
        4: upper yields
        8: digit yields
        16: other yields
        32 : upper sequence mark
    '''
    for c in s:

        if c.islower():
            if state & 1:
                yield s[si:ci]
                si = ci
            elif state & 2:
                yield s[si:ci - 1]
                si = ci - 1
            state = 4 | 8 | 16
            ci += 1

        elif c.isupper():
            if state & 4:
                yield s[si:ci]
                si = ci
            if state & 32:
                state = 2 | 8 | 16 | 32
            else:
                state = 8 | 16 | 32

            ci += 1

        elif c.isdigit():
            if state & 8:
                yield s[si:ci]
                si = ci
            state = 1 | 4 | 16
            ci += 1

        else:
            if state & 16:
                yield s[si:ci]
            state = 0
            ci += 1  # eat ci
            si = ci   
        print(' : ', c, bin(state))
    if state:
        yield s[si:ci] 


def camelcaseToUnderscore(s):
    return '_'.join(splitSymbol(s)) 

splitsymbol สามารถแยกวิเคราะห์เคสทุกชนิด: UpperSEQUENCE อินเทอร์เนล, under_score, BIG_SYMBOLS และ cammelCasedMethods

ฉันหวังว่ามันจะมีประโยชน์

ดัดแปลงมาจากhttps://stackoverflow.com/users/267781/matth ผู้ใช้เครื่องกำเนิดไฟฟ้า

def uncamelize(s):
    buff, l = '', []
    for ltr in s:
        if ltr.isupper():
            if buff:
                l.append(buff)
                buff = ''
        buff += ltr
    l.append(buff)
    return '_'.join(l).lower()

ดู lib Schematics ที่ยอดเยี่ยม

https://github.com/schematics/schematics

จะช่วยให้คุณสร้างโครงสร้างข้อมูลที่พิมพ์ที่สามารถทำให้เป็นอนุกรม / deserialize จากงูหลามจาวาสคริปต์รสชาติเช่น:

class MapPrice(Model):
    price_before_vat = DecimalType(serialized_name='priceBeforeVat')
    vat_rate = DecimalType(serialized_name='vatRate')
    vat = DecimalType()
    total_price = DecimalType(serialized_name='totalPrice')

วิธีการง่ายๆนี้ควรทำงาน:

import re

def convert(name):
    return re.sub(r'([A-Z]*)([A-Z][a-z]+)', lambda x: (x.group(1) + '_' if x.group(1) else '') + x.group(2) + '_', name).rstrip('_').lower()

• เรามองหาตัวอักษรพิมพ์ใหญ่ที่นำหน้าด้วยตัวพิมพ์ใหญ่ (หรือศูนย์) จำนวนใด ๆ และตามด้วยอักขระตัวพิมพ์เล็กจำนวนเท่าใดก็ได้
• ขีดล่างถูกวางไว้ก่อนการเกิดขึ้นของตัวอักษรตัวใหญ่สุดท้ายที่พบในกลุ่มและสามารถวางไว้ก่อนตัวอักษรตัวใหญ่ในกรณีที่มันจะนำหน้าด้วยตัวพิมพ์ใหญ่อื่น ๆ
• หากมีการขีดล่างขีดล่างเอาออก
• ในที่สุดสตริงผลลัพธ์ทั้งหมดจะถูกเปลี่ยนเป็นตัวพิมพ์เล็ก

(นำมาจากที่นี่ดูตัวอย่างการทำงานออนไลน์ )

ว้าวฉันเพิ่งขโมยมาจากตัวอย่าง django อ้างอิงhttp://djangosnippets.org/snippets/585/

สวยสง่า

camelcase_to_underscore = lambda str: re.sub(r'(?<=[a-z])[A-Z]|[A-Z](?=[^A-Z])', r'_\g<0>', str).lower().strip('_')

ตัวอย่าง:

camelcase_to_underscore('ThisUser')

ผลตอบแทน:

'this_user'

สาธิต REGEX

ตัวอย่างที่น่ากลัวโดยใช้นิพจน์ทั่วไป (คุณสามารถล้างสิ่งนี้ได้อย่างง่ายดาย :)):

def f(s):
    return s.group(1).lower() + "_" + s.group(2).lower()

p = re.compile("([A-Z]+[a-z]+)([A-Z]?)")
print p.sub(f, "CamelCase")
print p.sub(f, "getHTTPResponseCode")

ใช้งานได้กับ getHTTPResponseCode แม้ว่า!

อีกทางเลือกหนึ่งโดยใช้แลมบ์ดา:

p = re.compile("([A-Z]+[a-z]+)([A-Z]?)")
print p.sub(lambda x: x.group(1).lower() + "_" + x.group(2).lower(), "CamelCase")
print p.sub(lambda x: x.group(1).lower() + "_" + x.group(2).lower(), "getHTTPResponseCode")

แก้ไข: มันควรจะค่อนข้างง่ายที่จะเห็นว่ามีห้องพักสำหรับการปรับปรุงสำหรับกรณีเช่น "ทดสอบ" เพราะแทรกขีดเส้นใต้โดยไม่มีเงื่อนไข

นี่คือสิ่งที่ฉันทำเพื่อเปลี่ยนส่วนหัวของไฟล์ที่คั่นด้วยแท็บ ฉันจะข้ามส่วนที่ฉันแก้ไขบรรทัดแรกของไฟล์เท่านั้น คุณสามารถปรับให้เข้ากับ Python ได้อย่างง่ายดายด้วยไลบรารีใหม่ รวมถึงการแยกตัวเลขออกด้วย ฉันทำในสองขั้นตอนเพราะง่ายกว่าบอกว่าอย่าใส่ขีดเส้นใต้ที่จุดเริ่มต้นของบรรทัดหรือแท็บ

ขั้นตอนที่หนึ่ง ... ค้นหาตัวอักษรตัวพิมพ์ใหญ่หรือจำนวนเต็มนำหน้าด้วยตัวอักษรตัวเล็กและนำหน้าด้วยเครื่องหมายขีดล่าง:

ค้นหา:

([a-z]+)([A-Z]|[0-9]+)

เปลี่ยน:

\1_\l\2/

ขั้นตอนที่สอง ... ใช้ด้านบนและเรียกใช้อีกครั้งเพื่อแปลงตัวพิมพ์ใหญ่ทั้งหมดเป็นตัวพิมพ์เล็ก:

ค้นหา:

([A-Z])

การแทนที่ (นั่นคือแบ็กสแลช, ตัวพิมพ์เล็ก L, แบ็กสแลช, หนึ่งอัน):

\l\1

ฉันกำลังมองหาวิธีแก้ไขปัญหาเดียวกันยกเว้นว่าฉันต้องการโซ่ เช่น

"CamelCamelCamelCase" -> "Camel-camel-camel-case"

เริ่มต้นจากการแก้ปัญหาสองคำที่ดีที่นี่ฉันมาด้วยต่อไปนี้:

"-".join(x.group(1).lower() if x.group(2) is None else x.group(1) \
         for x in re.finditer("((^.[^A-Z]+)|([A-Z][^A-Z]+))", "stringToSplit"))

ตรรกะที่ซับซ้อนส่วนใหญ่คือการหลีกเลี่ยงการลดคำแรก นี่เป็นเวอร์ชั่นที่ง่ายกว่านี้ถ้าคุณไม่เปลี่ยนคำแรก:

"-".join(x.group(1).lower() for x in re.finditer("(^[^A-Z]+|[A-Z][^A-Z]+)", "stringToSplit"))

แน่นอนคุณสามารถรวบรวมการแสดงออกปกติหรือเข้าร่วมกับขีดล่างแทนยัติภังค์ตามที่กล่าวไว้ในการแก้ปัญหาอื่น ๆ

กระชับโดยไม่มีการแสดงออกปกติ แต่ HTTPResponseCode => httpresponse_code:

def from_camel(name):
    """
    ThisIsCamelCase ==> this_is_camel_case
    """
    name = name.replace("_", "")
    _cas = lambda _x : [_i.isupper() for _i in _x]
    seq = zip(_cas(name[1:-1]), _cas(name[2:]))
    ss = [_x + 1 for _x, (_i, _j) in enumerate(seq) if (_i, _j) == (False, True)]
    return "".join([ch + "_" if _x in ss else ch for _x, ch in numerate(name.lower())])

ไม่มีห้องสมุด:

def camelify(out):
    return (''.join(["_"+x.lower() if i<len(out)-1 and x.isupper() and out[i+1].islower()
         else x.lower()+"_" if i<len(out)-1 and x.islower() and out[i+1].isupper()
         else x.lower() for i,x in enumerate(list(out))])).lstrip('_').replace('__','_')

ค่อนข้างหนัก แต่

CamelCamelCamelCase ->  camel_camel_camel_case
HTTPRequest         ->  http_request
GetHTTPRequest      ->  get_http_request
getHTTPRequest      ->  get_http_request

RegEx ที่ดีมากเสนอบนเว็บไซต์นี้ :

(?<!^)(?=[A-Z])

ถ้าหลามมีวิธีการแบ่งสตริงมันควรจะทำงาน ...

ใน Java:

String s = "loremIpsum";
words = s.split("(?<!^)(?=[A-Z])");

def convert(name):
    return reduce(
        lambda x, y: x + ('_' if y.isupper() else '') + y, 
        name
    ).lower()

และถ้าเราต้องการที่จะครอบคลุมกรณีที่มีการป้อนข้อมูลอูฐแล้วยกเลิกการอูฐ:

def convert(name):
    return reduce(
        lambda x, y: x + ('_' if y.isupper() and not x.endswith('_') else '') + y, 
        name
    ).lower()

ในกรณีที่มีคนต้องการแปลงไฟล์ต้นฉบับแบบสมบูรณ์นี่คือสคริปต์ที่จะทำ

# Copy and paste your camel case code in the string below
camelCaseCode ="""
    cv2.Matx33d ComputeZoomMatrix(const cv2.Point2d & zoomCenter, double zoomRatio)
    {
      auto mat = cv2.Matx33d::eye();
      mat(0, 0) = zoomRatio;
      mat(1, 1) = zoomRatio;
      mat(0, 2) = zoomCenter.x * (1. - zoomRatio);
      mat(1, 2) = zoomCenter.y * (1. - zoomRatio);
      return mat;
    }
"""

import re
def snake_case(name):
    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()

def lines(str):
    return str.split("\n")

def unlines(lst):
    return "\n".join(lst)

def words(str):
    return str.split(" ")

def unwords(lst):
    return " ".join(lst)

def map_partial(function):
    return lambda values : [  function(v) for v in values]

import functools
def compose(*functions):
    return functools.reduce(lambda f, g: lambda x: f(g(x)), functions, lambda x: x)

snake_case_code = compose(
    unlines ,
    map_partial(unwords),
    map_partial(map_partial(snake_case)),
    map_partial(words),
    lines
)
print(snake_case_code(camelCaseCode))

ฉันโชคดีมากกับสิ่งนี้:

import re
def camelcase_to_underscore(s):
    return re.sub(r'(^|[a-z])([A-Z])',
                  lambda m: '_'.join([i.lower() for i in m.groups() if i]),
                  s)

นี้เห็นได้ชัดอาจจะเหมาะสำหรับความเร็วเล็กบิตถ้าคุณต้องการ

import re

CC2US_RE = re.compile(r'(^|[a-z])([A-Z])')

def _replace(match):
    return '_'.join([i.lower() for i in match.groups() if i])

def camelcase_to_underscores(s):
    return CC2US_RE.sub(_replace, s)

def convert(camel_str):
    temp_list = []
    for letter in camel_str:
        if letter.islower():
            temp_list.append(letter)
        else:
            temp_list.append('_')
            temp_list.append(letter)
    result = "".join(temp_list)
    return result.lower()

ใช้: str.capitalize()เพื่อแปลงอักษรตัวแรกของสตริง (มีอยู่ในตัวแปร str) เป็นตัวพิมพ์ใหญ่และส่งคืนสตริงทั้งหมด

ตัวอย่าง: คำสั่ง: "hello" .capitalize () เอาท์พุท: สวัสดี