# Python
## Data Types
| Text Type: | `str` |
| --------------- | ---------------------------------- |
| Numeric Types: | `int`, `float`, `complex` |
| Sequence Types: | `list`, `tuple`, `range` |
| Mapping Type: | `dict` |
| Set Types: | `set`, `frozenset` |
| Boolean Type: | `bool` |
| Binary Types: | `bytes`, `bytearray`, `memoryview` |
| None Type: | `NoneType` |
```python
x = 5
# Check the typing and get the type
print(type(x), isInstance(x, str))
```
### String
* F-String was introduced in Python 3.6, which can be used to concatenate the string and variable
```python
age = 36
txt = f"My name is John, I am {age}"
print(txt)
```
### Logical
* `and` : &&
* `or`: ||
* `not`: !
```python
a = True
b = False
if not b:
print("b is false ar")
if a or b:
print("a or b is true")
if a and b:
print("a and b are true")
# Result
# b is false ar
# a or b is true
```
* `is` vs `==`
* `is` is more strict than `==`, as it also validate the object reference
```python
x = ["apple", "banana"]
y = ["apple", "banana"]
z = x
print(x is z)
# returns False because z is the same object as x
print(x is y)
# returns True because x is not the same object as y, even if they have the same content
print(x == y)
# to demonstrate the difference betweeen "is not" and "!=": this comparison returns False because x is equal to y
# Result
# True
# False
# True
```
### Boolean
* `()`, `[]`, `{}`, `""` , `0` , `None` , will equal to false
```python
a = {}
if a:
print("Yeah")
else:
print("Nope")
# result: Nope
```
### List
```python
thislist = ["apple", "banana", "cherry"]
# cherry
print(thislist[-1])
# ['cherry', 'orange', 'kiwi']
print(thislist[2:5])
# add the element on the specific position
thislist.insert(2, "watermelon")
# append the element to the last position
thislist.add("lemon")
# pop the element on specific position, if arg is none, pop the last element
thislist.pop(1)
# Looping
thislist = ["apple", "banana", "cherry"]
for x in thislist:
print(x)
# Join List
list1 = ["a"]
list2 = [1]
list3 = list1 + list2
print(list3)
# ["a", 1]
```
* List Comprehension is similar with map method on javascript, having syntax sugar to create new array from a array
```python
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = [x for x in fruits if "a" in x]
print(newlist)
# ['apple', 'banana', 'mango']
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = [x if x != "banana" else "orange" for x in fruits]
print(newlist)
# ['apple', 'orange', 'cherry', 'kiwi', 'mango']
def add(x:int):
return x + 1
arr = [1 ,2 ,3 ,4 ,5]
arr2 = [ y for item in arr if (y:=add(item)) <=3]
print(arr2)
# [2,3]
```
thislist = ["apple", "banana", "cherry"]
# Create new list with different reference
mylist = thislist.copy()
print(thislist is mylist)
# Same reference
yourlist = thislist
print(thislist is yourlist)
# Result
# False
# True
### Tuple
* A tuple is a collection which is ordered and **unchangeable**.
```python
mytuple = ("apple", "banana", "cherry")
```
### Set
* A set is a collection which is *unordered*, *unchangeable\**, and *unindexed*
```python
myset = {"apple", "banana", "cherry"}
```
### Dictionaries
* Dictionaries which is similar with json object from javascript, containing key-value pair
```python
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
# Loop the key
# brand , model, year
for x in thisdict:
print(x)
# Ford
print(thisdict["brand"])
# Will crash, don't try to access non-existing key
print(thisdict["brands"])
# Check the key is existed
# False
print("brands" in thisdict)
# Directly add or edit attribute
thisdict["year"] = 2018
# remove attribute
thisdict.pop("model")
# convert string to dictionaries
newobj = json.loads('{ "name":"John", "age":30, "city":"New York"}')
# stringify the dictionaries
newStr = json.dumps(thisdict)
```
## Function
* Here is the example of closure
```python
def test():
def test2():
return "test"
return test2
# Result
# test
print(test()())
```
* In function , you can assign a default value to function argument, but need to take care of `list`, `dict`, as they are mutable and have unexpected behaviors
```python
class Test:
def fn(
self,
param:list = []
):
param.append(1);
print(param);
test = Test();
test2 = Test();
test.fn()
test2.fn()
// Output:
// [1]
// [1, 1]
```
* From above the result, since the default parameter is mutable, so the value is accumulated
* Here is the fix below, by setting default parameter as None
```python
class Test:
def fn(
self,
param:list = None
):
param = [] if param is None else param
param.append(1);
print(param);
test = Test();
test2 = Test();
test.fn()
test2.fn()
// Output:
// [1]
// [1]
```
## Lambda
* lambda function is a small anonymous function with a simple return value
```python
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
# Result: 22
print(mydoubler(11))
```
## Class
```python
# In the class declarification, self must included, self is equal to this
class Person:
# init which equal to constructor function
def __init__(self, name, age):
self.name = name
self.age = age
# To customize tthe format when accessing the class instance directly
def __str__(self):
return f"{self.name}({self.age})"
p1 = Person("John", 36)
# John
print(p1.name)
# John(36)
print(p1)
```
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://petercheng7788.gitbook.io/developer-note/programming-language/python.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.