1. Creating a List

To conjure a list into being:

# A list of mystical elements
elements = ['Earth', 'Air', 'Fire', 'Water']

2. Appending to a List

To append a new element to the end of a list:

elements.append('Aether')

3. Inserting into a List

To insert an element at a specific position in the list:

# Insert 'Spirit' at index 1
elements.insert(1, 'Spirit')

4. Removing from a List

To remove an element by value from the list:

elements.remove('Earth')  # Removes the first occurrence of 'Earth'

5. Popping an Element from a List

To remove and return an element at a given index (default is the last item):

last_element = elements.pop()  # Removes and returns the last element

6. Finding the Index of an Element

To find the index of the first occurrence of an element:

index_of_air = elements.index('Air')

7. List Slicing

To slice a list, obtaining a sub-list:

# Get elements from index 1 to 3
sub_elements = elements[1:4]

8. List Comprehension

To create a new list by applying an expression to each element of an existing one:

# Create a new list with lengths of each element
lengths = [len(element) for element in elements]

9. Sorting a List

To sort a list in ascending order (in-place):

elements.sort()

10. Reversing a List

To reverse the elements of a list in-place:

elements.reverse()

1. Basic GET Request

To fetch data from an API endpoint using a GET request:

import requests
response = requests.get('https://api.example.com/data')
data = response.json()  # Assuming the response is JSON
print(data)

2. GET Request with Query Parameters

To send a GET request with query parameters:

import requests
params = {'key1': 'value1', 'key2': 'value2'}
response = requests.get('https://api.example.com/search', params=params)
data = response.json()
print(data)

3. Handling HTTP Errors

To handle possible HTTP errors gracefully:

import requests
response = requests.get('https://api.example.com/data')
try:
    response.raise_for_status()  # Raises an HTTPError if the status is 4xx, 5xx
    data = response.json()
    print(data)
except requests.exceptions.HTTPError as err:
    print(f'HTTP Error: {err}')

4. Setting Timeout for Requests

To set a timeout for API requests to avoid hanging indefinitely:

import requests
try:
    response = requests.get('https://api.example.com/data', timeout=5)  # Timeout in seconds
    data = response.json()
    print(data)
except requests.exceptions.Timeout:
    print('The request timed out')

5. Using Headers in Requests

To include headers in your request (e.g., for authorization):

import requests
headers = {'Authorization': 'Bearer YOUR_ACCESS_TOKEN'}
response = requests.get('https://api.example.com/protected', headers=headers)
data = response.json()
print(data)

6. POST Request with JSON Payload

To send data to an API endpoint using a POST request with a JSON payload:

import requests
payload = {'key1': 'value1', 'key2': 'value2'}
headers = {'Content-Type': 'application/json'}
response = requests.post('https://api.example.com/submit', json=payload, headers=headers)
print(response.json())

7. Handling Response Encoding

To handle the response encoding properly:

import requests
response = requests.get('https://api.example.com/data')
response.encoding = 'utf-8'  # Set encoding to match the expected response format
data = response.text
print(data)

8. Using Sessions with Requests

To use a session object for making multiple requests to the same host, which can improve performance:

import requests
with requests.Session() as session:
    session.headers.update({'Authorization': 'Bearer YOUR_ACCESS_TOKEN'})
    response = session.get('https://api.example.com/data')
    print(response.json())

9. Handling Redirects

To handle or disable redirects in requests:

import requests
response = requests.get('https://api.example.com/data', allow_redirects=False)
print(response.status_code)

10. Streaming Large Responses

To stream a large response to process it in chunks, rather than loading it all into memory:

import requests
response = requests.get('https://api.example.com/large-data', stream=True)
for chunk in response.iter_content(chunk_size=1024):
    process(chunk)  # Replace 'process' with your actual processing function

https://blog.stackademic.com/ultimate-python-cheat-sheet-practical-python-for-everyday-tasks-c267c1394ee8

1. Reading a File

To read the entire content of a file:

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

2. Writing to a File

To write text to a file, overwriting existing content:

with open('example.txt', 'w') as file:
    file.write('Hello, Python!')

3. Appending to a File

To add text to the end of an existing file:

with open('example.txt', 'a') as file:
    file.write('\nAppend this line.')

4. Reading Lines into a List

To read a file line by line into a list:

with open('example.txt', 'r') as file:
    lines = file.readlines()
    print(lines)

5. Iterating Over Each Line in a File

To process each line in a file:

with open('example.txt', 'r') as file:
    for line in file:
        print(line.strip())

6. Checking If a File Exists

To check if a file exists before performing file operations:

import os
if os.path.exists('example.txt'):
    print('File exists.')
else:
    print('File does not exist.')

7. Writing Lists to a File

To write each element of a list to a new line in a file:

lines = ['First line', 'Second line', 'Third line']
with open('example.txt', 'w') as file:
    for line in lines:
        file.write(f'{line}\n')

8. Using With Blocks for Multiple Files

To work with multiple files simultaneously using with blocks:

with open('source.txt', 'r') as source, open('destination.txt', 'w') as destination:
    content = source.read()
    destination.write(content)

9. Deleting a File

To safely delete a file if it exists:

import os
if os.path.exists('example.txt'):
    os.remove('example.txt')
    print('File deleted.')
else:
    print('File does not exist.')

10. Reading and Writing Binary Files

To read from and write to a file in binary mode (useful for images, videos, etc.):

# Reading a binary file
with open('image.jpg', 'rb') as file:
    content = file.read()
# Writing to a binary file
with open('copy.jpg', 'wb') as file:
    file.write(content)

https://blog.stackademic.com/ultimate-python-cheat-sheet-practical-python-for-everyday-tasks-c267c1394ee8

Pandas는 데이터 분석, 조작 및 시각화를 위한 인기 있는 Python 라이브러리입니다. 구조화된 데이터와 구조화되지 않은 데이터를 포함하여 다양한 형식의 데이터를 쉽고 효과적으로 작업할 수 있는 풍부한 도구와 기능을 제공합니다. 이 문서에서는 Python에서 빠르고 효율적으로 데이터 분석을 수행하는 데 사용할 수 있는 일반적인 pandas 작업과 함수에 대한 치트시트를 제공합니다.

import pandas as pd

Pandas 라이브러리를 가져온 후에는 다음 작업과 함수를 사용하여 일반적인 데이터 분석 작업을 수행할 수 있습니다.

• pd.read_csv(filename): CSV 파일에서 데이터를 로드합니다.
• data.head(): 데이터 프레임의 처음 몇 행을 봅니다.
• data.tail(): 데이터 프레임의 마지막 몇 행을 봅니다.
• data.describe(): 숫자 열에 대한 요약 통계를 계산합니다.
• data.info(): 데이터 프레임의 데이터 유형과 메모리 사용량을 확인합니다.
• data.columns: 데이터 프레임의 열을 봅니다.
• data['column']: 데이터 프레임의 열을 선택합니다.
• data.loc[row_index]: 인덱스를 기준으로 데이터 프레임의 행을 선택합니다.
• data.iloc[row_index]: 위치를 기준으로 데이터 프레임의 행을 선택합니다.
• data.dropna(): 값이 누락된 행을 삭제합니다.
• data.fillna(value): 누락된 값을 주어진 값으로 채웁니다.
• data.rename(columns={'old': 'new'}): 데이터 프레임의 열 이름을 바꿉니다.
• data.sort_values(by='column'): 열의 값을 기준으로 데이터 프레임을 정렬합니다.
• data.groupby('column')['column'].mean(): 열의 값으로 데이터 프레임을 그룹화하고 다른 열의 평균을 계산합니다.
• data.plot.hist(): 수치적 히스토그램을 그리다

LEGB Rule

• 파이썬 변수 scope 룰을 LEGB 룰이라고 불리기도 합니다.
• 변수가 값을 찾을 때, Local -> Enclosed -> Global -> Built-in
• local - 가장 가까운 함수안 범위 입니다.
• Enclosed - 파이썬은 함수 안에 함수가 정의 될수 있는데, 가장 가까운 함수가 아닌 두번째 이상의 함수 가까운 함수범위입니다.
• Global - 함수 바깥의 변수 또는 import된 module
• Built-in - 파이썬안에 내장되어 있는 함수 또는 속성들입니다.

>>> a = 5    # Global
>>> b = 10   # Global
>>> def outer():
...     a = 10  # outer함수의 local이며, inner함수의 Enclosed
...     def inner():
...             c=30 # inner 함수의 local
...             print(a, b, c)
...     inner()
...     a = 22  # outer함수의 local이며, inner함수의 Enclosed
...     inner()
... 
>>> outer()
10 10 30  
22 10 30

"""_summary_
얕은 복사(shallow copy)
    list의 슬라이싱을 통한 새로운 값을 할당해봅니다.
    아래의 결과와 같이 슬라이싱을 통해서 값을 할당하면 새로운 id가 부여되며, 서로 영향을 받지 않습니다
"""

print("\n","*" * 30, "\n   얕은 복사(shallow copy) \n","*" * 30) 

a = [1, 2, 3]
b = a[:]
print(" a = ", a)
print(" b = ", b)

print(" id(a) : ", id(a)) #다른 주소
print(" id(b) : ", id(b))

print(" a == b : ", a == b)
print(" a is b : ", a is b)

b[0] = 5

print(a)
print(b)

""" 
    하지만, 이러한 슬라이싱 또한 얕은 복사에 해당합니다.
    리스트안에 리스트 mutable객체 안에 mutable객체인 경우 문제가 됩니다.
    id(a) 값과 id(b) 값은 다르게 되었지만, 그 내부의 객체 id(a[0])과 id(b[0])은 같은 주소를 바라보고 있습니다
"""
a = [[1,2],[3,4]]
b = a[:]
print(" id(a) : ", id(a)) #다른 주소
print(" id(b) : ", id(b))

print(" id(a[0]) : ",id(a[0])) #같은 주소
print(" id(b[0]) : ",id(b[0]))


"""깊은 복사(deep copy)
    깊은 복사는 내부에 객체들까지 모두 새롭게 copy 되는 것입니다.
    copy.deepcopy메소드가 해결해줍니다
"""
print("\n","*" * 30, "\n   deepcopy \n","*" * 30)  

import copy

a = [[1,2],[3,4]]
b = copy.deepcopy(a)
a[1].append(5)

print(" a : ", a)
print(" b : ", b)

print(" id(a) : ", id(a)) #다른 주소
print(" id(b) : ", id(b))