Förstå Pythons summafunktion [With Examples]

Utforska Python: Summafunktionen i Detalj

Den inbyggda funktionen sum() i Python är ett kraftfullt verktyg för att addera element i itererbara objekt. Oavsett om du arbetar med listor, tupler eller set av numeriska värden, är sum() ett effektivt och elegant sätt att beräkna totaler. I den här guiden ska vi gå igenom allt du behöver veta om hur du använder sum(), från grundläggande syntax till avancerade användningsområden.

Innan vi dyker in i sum(), ska vi snabbt granska andra metoder för att summera element, som att använda loopar och anpassade funktioner. Sedan ska vi utforska hur sum() fungerar i olika scenarier, inklusive användning med olika datatyper och hur man kan hantera eventuella fallgropar.

Alternativa metoder för Summering

Låt oss anta att vi har följande lista med tal:

    
    nums = [2, 8, 5, 3, 11, 7, 9]
    
  

Innan vi ser hur sum() underlättar beräkningen av summan, ska vi undersöka alternativa metoder.

Användning av Loopar

En grundläggande metod för att addera alla element i en lista är att använda en for-loop. Här initierar vi en variabel total med noll och itererar sedan genom listan, och adderar varje element till total:

    
    total = 0
    for num in nums:
        total += num
    print(total) # Output: 45
    
  

Användning av reduce()-funktionen

Funktionen reduce() från modulen functools kan också användas för att summera element i en itererbar. Den tar en funktion och en itererbar som argument. Här använder vi en lambda-funktion för att definiera additionen:

    
    from functools import reduce
    total = reduce(lambda n1, n2: n1 + n2, nums)
    print(total) # Output: 45
    
  

Använda en Anpassad Funktion

Vi kan också skapa en anpassad funktion för att beräkna summan. Här är ett exempel på en funktion sum_list() som tar en lista som argument och returnerar dess summa:

    
    def sum_list(some_list):
        total = 0
        for num in some_list:
            total += num
        return total

    total = sum_list(nums)
    print(total) # Output: 45
    
  

Syntax för Python sum()-funktionen

Syntaxen för sum() är enkel:

      
      sum(iterable, start)
      
    

Där:

• iterable är obligatoriskt och kan vara en lista, tupel, set eller annan typ av itererbart objekt.
• start är ett valfritt argument som anger ett startvärde som ska adderas till summan.

Använda sum()-funktionen för Olika Iterables

Lista

Låt oss använda sum() för att beräkna summan av nums-listan:

      
      sum_1 = sum(nums)
      print(sum_1) # Output: 45
      
    

Använda startvärdet

Vi kan lägga till ett startvärde till summan med argumentet start:

        
          sum_start = sum(nums, 100)
          print(sum_start) # Output: 145
        
      

Tupel

sum() fungerar även med tupler. Vi konverterar nums-listan till en tupel och beräknar dess summa:

      
        nums_tuple = tuple(nums)
        sum_2 = sum(nums_tuple)
        print(sum_2) # Output: 45
      
    

Set

sum() kan också användas med set. Vi skapar ett set från nums och summerar elementen:

        
          nums_set = set(nums)
          sum_3 = sum(nums_set)
          print(sum_3) # Output: 45
        
      

Lexikon

Om vi använder sum() med ett lexikon, kommer den som standard att addera nycklarna. Låt oss se ett exempel:

      
        students_dict = {1: 106, 2: 112, 3: 127}
        sum_4 = sum(students_dict)
        print(sum_4) # Output: 6
      
    

Summera nycklarna

Vi kan explicit summera nycklarna genom att använda .keys():

    
    sum_keys = sum(students_dict.keys())
    print(sum_keys) # Output: 6
    
  

Summera värdena

För att summera värdena använder vi .values():

      
        sum_vals = sum(students_dict.values())
        print(sum_vals) # Output: 345
      
    

Summafunktionen med Andra Numeriska Datatyper

Komplexa tal

sum() kan även addera komplexa tal:

      
        nums_c = [3 + 4j, 1 + 2j]
        sum_c = sum(nums_c)
        print(sum_c) # Output: (4+6j)
      
    

Flyttalssiffror

Här använder vi sum() för att addera flyttalsvärden:

    
    nums_f = [1.8, 2.5, 3.6, 7.2]
    sum_f = sum(nums_f)
    print(sum_f) # Output: 15.100000000000001
    
  

För mer exakt beräkning av flyttalsummor, kan funktionen fsum() från modulen math användas.

Plattning med Summafunktionen

sum() kan användas för att platta ut nästlade listor.

Platta ut en lista

Om vi har en nästlad lista:

    
    lists = [[2, 4, 6], [3, 5, 7]]
    
  

Genom att använda sum() med en tom lista som startvärde kan vi platta ut listan:

      
        flat_list = sum(lists, [])
        print(flat_list) # Output: [2, 4, 6, 3, 5, 7]
      
    

Vanlig fallgrop: Använd inte sum() med strängar

Försöker vi addera strängar med sum(), får vi ett TypeError:

    
    # sum(['a', 'b', 'c'], '')  # Ger TypeError
    
    

Använd istället metoden .join() för att slå ihop strängar:

    
      joined_string = ''.join(['a', 'b', 'c'])
      print(joined_string) # Output: abc
    
  

Slutsats

I den här handledningen har vi utforskat sum()-funktionen i Python. Vi har sett hur man kan använda den för att addera element i olika typer av itererbara objekt, inklusive listor, tupler, set och lexikon. Vi har även tittat på hur man kan använda sum() med olika numeriska datatyper och hur man undviker vanliga fallgropar. Funktionen sum() är ett effektivt och mångsidigt verktyg för att beräkna summor i Python.

Nästa steg kan vara att undersöka hur map()-funktionen fungerar i Python. Läs mer om Python map() här