import pandas as pd
data = {
'name': ['Rick', 'Carol', 'Carl', 'Negan'],
'place': ['Alexendria', 'Kingdom', 'Alexendria', 'Saviours']
}
df = pd.DataFrame.from_dict(data)
print(df)
# name place
# 0 Rick Alexendria
# 1 Carol Kingdom
# 2 Carl Alexendria
# 3 Negan Saviours
# Get dict from dataframe(Method 1)
dict1 = dict(df.values)
print(dict1)
# -> {'Rick': 'Alexendria', 'Carol': 'Kingdom', 'Carl': 'Alexendria', 'Negan': 'Saviours'}
# Get dict from dataframe(Method 2)
dict2 = df.to_dict('index')
print(dict2)
# -> {0: {'name': 'Rick', 'place': 'Alexendria'}, 1: {'name': 'Carol', 'place': 'Kingdom'}, 2: {'name': 'Carl', 'place': 'Alexendria'}, 3: {'name': 'Negan', 'place': 'Saviours'}}
# By comparing itself
def is_nan(val):
return val != val
nan_value = float("nan")
print(is_nan(nan_value))
# -> True
#Using math.isnan(Import math before using math.isnan)
import math
nan_value = float("NaN")
check_nan = math.isnan(nan_value)
print(check_nan)
# -> True
str_1 = "Hello"
str_2 = "Devsheet"
#Using .format() method
#Using blank curly brackets
new_str_1 = "Welcome User {} from {}".format(str_1, str_2)
print(new_str_1)
# -> Welcome User Hello from Devsheet
#Using variable names
new_str_2 = "{s1} from {s2}.".format(s1=str_1, s2=str_2)
print(new_str_2)
# -> Hello from Devsheet.
def sanatize_list(lst):
return list(filter(bool,lst))
list_eg_1 = ["Devsheet", None, "", False]
eg_1_result = sanatize_list(list_eg_1)
print(eg_1_result)
# -> ['Devsheet']
list_eg_2 = [None, "John", False, "Deo"]
eg_2_result = sanatize_list(list_eg_2)
print(eg_2_result)
# -> ['John', 'Deo']
list_eg_3 = [[], "Apple", (), {}]
eg_3_result = sanatize_list(list_eg_3)
print(eg_3_result)
import datetime, timedelta
n = 10
time_difference = datetime.now() - timedelta(hours=n)
result = session.query(User).filter(
User.last_active_timestamp < time_difference
)
import calendar
select_year = 2021
select_month = 11
print(calendar.month(select_year, select_month))
# November 2021
# Mo Tu We Th Fr Sa Su
# 1 2 3 4 5 6 7
# 8 9 10 11 12 13 14
# 15 16 17 18 19 20 21
# 22 23 24 25 26 27 28
# 29 30
from sqlalchemy import func
session.query(func.max(table_name.column_name))
#To get all records
session.query(func.max(table_name.column_name)).all()
#To get first record
session.query(func.max(table_name.column_name)).first()
$ celery -A <project_name> worker -E -l INFO
$ celery -A <project_name> beat -E -l INFO
#without using regex
def validate_password(password):
special_chars =['$', '!', '@', '#', '%', '&']
validated = True
msg = ''
if len(password) < 8:
msg = 'Password length must be at least 8'
validated = False
elif len(password) > 18:
msg = 'Password length must not be greater than 18'
validated = False
elif not any(char.isdigit() for char in password):
msg = 'Password should have at least one number'
validated = False
elif not any(char.isupper() for char in password):
msg = 'Password should have at least one uppercase letter'
validated = False
elif not any(char.islower() for char in password):
msg = 'Password should have at least one lowercase letter'
validated = False
elif not any(char in special_chars for char in password):
msg = 'Password should have at least one special character'
validated = False
return { 'is_valid': validated, 'message': msg }
print(validate_password('Hellowewew1@'))
#Using pandas DataFrame
import pandas as pd
d = {'x': 1,
'y': {'a': 2, 'b': {'c': 3, 'd' : 4}},
'z': {'a': 2, 'b': {'c': 3, 'd' : 4}}}
dframe = pd.json_normalize(d, sep='_')
print(dframe.to_dict(orient='records')[0])
#By creating a copy - using df.rename() method
df = df.rename(columns={'col_1': 'changed_col_1', 'col_2': 'changed_col_2'})
print(df)
#Without creating copy - using df.rename() method with inplace=True
df.rename(columns={'col_1': 'changed_col_1', 'col_2': 'changed_col_2'}, inplace=True)
print(df)
my_str = "Devsheet"
my_list = list(my_str)
print(my_list)
#-> ['D', 'e', 'v', 's', 'h', 'e', 'e', 't']
#By throwing error
def check_int(value):
try:
value_int = int(value)
return 'Value is integer'
except ValueError:
return 'Not an integer'
check_int_response = check_int('20')
print(check_int_response)
# using isdigit() method - only for string format and positive values
value = "20"
if value.isdigit():
print("value is integer")
else:
print("value is not integer")
"""FlatDict is a dict object that allows for single level, delimited
key/value pair mapping of nested dictionaries.
"""
from collections.abc import MutableMapping
NO_DEFAULT = object()
class FlatDict(MutableMapping):
""":class:`~flatdict.FlatDict` is a dictionary object that allows for
single level, delimited key/value pair mapping of nested dictionaries.
The default delimiter value is ``:`` but can be changed in the constructor
or by calling :meth:`FlatDict.set_delimiter`.
"""
_COERCE = dict
def __init__(self, value=None, delimiter=":", dict_class=dict):
super(FlatDict, self).__init__()
self._values = dict_class()
self._delimiter = delimiter
self.update(value)
def __contains__(self, key):
"""Check to see if the key exists, checking for both delimited and
not delimited key values.
:param mixed key: The key to check for
"""
if self._has_delimiter(key):
pk, ck = key.split(self._delimiter, 1)
return pk in self._values and ck in self._values[pk]
return key in self._values
def __delitem__(self, key):
"""Delete the item for the specified key, automatically dealing with
nested children.
:param mixed key: The key to use
:raises: KeyError
"""
if key not in self:
raise KeyError
if self._has_delimiter(key):
pk, ck = key.split(self._delimiter, 1)
del self._values[pk][ck]
if not self._values[pk]:
del self._values[pk]
else:
del self._values[key]
def __eq__(self, other):
"""Check for equality against the other value
:param other: The value to compare
:type other: FlatDict
:rtype: bool
:raises: TypeError
"""
if isinstance(other, dict):
return self.as_dict() == other
elif not isinstance(other, self.__class__):
raise TypeError
return self.as_dict() == other.as_dict()
def __ne__(self, other):
"""Check for inequality against the other value
:param other: The value to compare
:type other: dict or FlatDict
:rtype: bool
"""
return not self.__eq__(other)
def __getitem__(self, key):
"""Get an item for the specified key, automatically dealing with
nested children.
:param mixed key: The key to use
:rtype: mixed
:raises: KeyError
"""
values = self._values
key = [key] if isinstance(key, int) else key.split(self._delimiter)
for part in key:
values = values[part]
return values
def __iter__(self):
"""Iterate over the flat dictionary key and values
:rtype: Iterator
:raises: RuntimeError
"""
return iter(self.keys())
def __len__(self):
"""Return the number of items.
:rtype: int
"""
return len(self.keys())
def __reduce__(self):
"""Return state information for pickling
:rtype: tuple
"""
return type(self), (self.as_dict(), self._delimiter)
def __repr__(self):
"""Return the string representation of the instance.
:rtype: str
"""
return '<{} id={} {}>"'.format(self.__class__.__name__, id(self), str(self))
def __setitem__(self, key, value):
"""Assign the value to the key, dynamically building nested
FlatDict items where appropriate.
:param mixed key: The key for the item
:param mixed value: The value for the item
:raises: TypeError
"""
if isinstance(value, self._COERCE) and not isinstance(value, FlatDict):
value = self.__class__(value, self._delimiter)
if self._has_delimiter(key):
pk, ck = key.split(self._delimiter, 1)
if pk not in self._values:
self._values[pk] = self.__class__({ck: value}, self._delimiter)
return
elif not isinstance(self._values[pk], FlatDict):
raise TypeError("Assignment to invalid type for key {}".format(pk))
self._values[pk][ck] = value
else:
self._values[key] = value
def __str__(self):
"""Return the string value of the instance.
:rtype: str
"""
return "{{{}}}".format(
", ".join(["{!r}: {!r}".format(k, self[k]) for k in self.keys()])
)
def as_dict(self):
"""Return the :class:`~flatdict.FlatDict` as a :class:`dict`
:rtype: dict
"""
out = dict({})
for key in self.keys():
if self._has_delimiter(key):
pk, ck = key.split(self._delimiter, 1)
if self._has_delimiter(ck):
ck = ck.split(self._delimiter, 1)[0]
if isinstance(self._values[pk], FlatDict) and pk not in out:
out[pk] = {}
if isinstance(self._values[pk][ck], FlatDict):
out[pk][ck] = self._values[pk][ck].as_dict()
else:
out[pk][ck] = self._values[pk][ck]
else:
out[key] = self._values[key]
return out
def clear(self):
"""Remove all items from the flat dictionary."""
self._values.clear()
def copy(self):
"""Return a shallow copy of the flat dictionary.
:rtype: flatdict.FlatDict
"""
return self.__class__(self.as_dict(), delimiter=self._delimiter)
def get(self, key, d=None):
"""Return the value for key if key is in the flat dictionary, else
default. If default is not given, it defaults to ``None``, so that this
method never raises :exc:`KeyError`.
:param mixed key: The key to get
:param mixed d: The default value
:rtype: mixed
"""
try:
return self.__getitem__(key)
except KeyError:
return d
def items(self):
"""Return a copy of the flat dictionary's list of ``(key, value)``
pairs.
.. note:: CPython implementation detail: Keys and values are listed in
an arbitrary order which is non-random, varies across Python
implementations, and depends on the flat dictionary's history of
insertions and deletions.
:rtype: list
"""
return [(k, self.__getitem__(k)) for k in self.keys()]
def iteritems(self):
"""Return an iterator over the flat dictionary's (key, value) pairs.
See the note for :meth:`flatdict.FlatDict.items`.
Using ``iteritems()`` while adding or deleting entries in the flat
dictionary may raise :exc:`RuntimeError` or fail to iterate over all
entries.
:rtype: Iterator
:raises: RuntimeError
"""
for item in self.items():
yield item
def iterkeys(self):
"""Iterate over the flat dictionary's keys. See the note for
:meth:`flatdict.FlatDict.items`.
Using ``iterkeys()`` while adding or deleting entries in the flat
dictionary may raise :exc:`RuntimeError` or fail to iterate over all
entries.
:rtype: Iterator
:raises: RuntimeError
"""
for key in self.keys():
yield key
def itervalues(self):
"""Return an iterator over the flat dictionary's values. See the note
:meth:`flatdict.FlatDict.items`.
Using ``itervalues()`` while adding or deleting entries in the flat
dictionary may raise a :exc:`RuntimeError` or fail to iterate over all
entries.
:rtype: Iterator
:raises: RuntimeError
"""
for value in self.values():
yield value
def keys(self):
"""Return a copy of the flat dictionary's list of keys.
See the note for :meth:`flatdict.FlatDict.items`.
:rtype: list
"""
keys = []
for key, value in self._values.items():
if isinstance(value, (FlatDict, dict)):
nested = [
self._delimiter.join([str(key), str(k)]) for k in value.keys()
]
keys += nested if nested else [key]
else:
keys.append(key)
return keys
def pop(self, key, default=NO_DEFAULT):
"""If key is in the flat dictionary, remove it and return its value,
else return default. If default is not given and key is not in the
dictionary, :exc:`KeyError` is raised.
:param mixed key: The key name
:param mixed default: The default value
:rtype: mixed
"""
if key not in self and default != NO_DEFAULT:
return default
value = self[key]
self.__delitem__(key)
return value
def setdefault(self, key, default):
"""If key is in the flat dictionary, return its value. If not,
insert key with a value of default and return default.
default defaults to ``None``.
:param mixed key: The key name
:param mixed default: The default value
:rtype: mixed
"""
if key not in self:
self.__setitem__(key, default)
return self.__getitem__(key)
def set_delimiter(self, delimiter):
"""Override the default or passed in delimiter with a new value. If
the requested delimiter already exists in a key, a :exc:`ValueError`
will be raised.
:param str delimiter: The delimiter to use
:raises: ValueError
"""
for key in self.keys():
if delimiter in key:
raise ValueError(
"Key {!r} collides with delimiter {!r}", key, delimiter
)
self._delimiter = delimiter
for key in self._values.keys():
if isinstance(self._values[key], FlatDict):
self._values[key].set_delimiter(delimiter)
def update(self, other=None, **kwargs):
"""Update the flat dictionary with the key/value pairs from other,
overwriting existing keys.
``update()`` accepts either another flat dictionary object or an
iterable of key/value pairs (as tuples or other iterables of length
two). If keyword arguments are specified, the flat dictionary is then
updated with those key/value pairs: ``d.update(red=1, blue=2)``.
:param iterable other: Iterable of key, value pairs
:rtype: None
"""
[self.__setitem__(k, v) for k, v in dict(other or kwargs).items()]
def values(self):
"""Return a copy of the flat dictionary's list of values. See the note
for :meth:`flatdict.FlatDict.items`.
:rtype: list
"""
return [self.__getitem__(k) for k in self.keys()]
def _has_delimiter(self, key):
"""Checks to see if the key contains the delimiter.
:rtype: bool
"""
return isinstance(key, str) and self._delimiter in key
class FlatterDict(FlatDict):
"""Like :class:`~flatdict.FlatDict` but also coerces lists and sets
to child-dict instances with the offset as the key. Alternative to
the implementation added in v1.2 of FlatDict.
"""
_COERCE = list, tuple, set, dict, FlatDict
_ARRAYS = list, set, tuple
def __init__(self, value=None, delimiter=":", dict_class=dict):
self.original_type = type(value)
if self.original_type in self._ARRAYS:
value = {str(i): v for i, v in enumerate(value)}
super(FlatterDict, self).__init__(value, delimiter, dict_class)
def __setitem__(self, key, value):
"""Assign the value to the key, dynamically building nested
FlatDict items where appropriate.
:param mixed key: The key for the item
:param mixed value: The value for the item
:raises: TypeError
"""
if isinstance(value, self._COERCE) and not isinstance(value, FlatterDict):
value = self.__class__(value, self._delimiter)
if self._has_delimiter(key):
pk, ck = key.split(self._delimiter, 1)
if pk not in self._values:
self._values[pk] = self.__class__({ck: value}, self._delimiter)
return
if getattr(self._values[pk], "original_type", None) in self._ARRAYS:
try:
k, cck = ck.split(self._delimiter, 1)
int(k)
except ValueError:
raise TypeError(
"Assignment to invalid type for key {}{}{}".format(
pk, self._delimiter, ck
)
)
self._values[pk][k][cck] = value
return
elif not isinstance(self._values[pk], FlatterDict):
raise TypeError("Assignment to invalid type for key {}".format(pk))
self._values[pk][ck] = value
else:
self._values[key] = value
def as_dict(self):
"""Return the :class:`~flatdict.FlatterDict` as a nested
:class:`dict`.
:rtype: dict
"""
out = {}
for key in self.keys():
if self._has_delimiter(key):
pk, ck = key.split(self._delimiter, 1)
if self._has_delimiter(ck):
ck = ck.split(self._delimiter, 1)[0]
if isinstance(self._values[pk], FlatterDict) and pk not in out:
if self._values[pk].original_type == tuple:
out[pk] = tuple(self._child_as_list(pk))
elif self._values[pk].original_type == list:
out[pk] = self._child_as_list(pk)
elif self._values[pk].original_type == set:
out[pk] = set(self._child_as_list(pk))
elif self._values[pk].original_type == dict:
out[pk] = self._values[pk].as_dict()
else:
if isinstance(self._values[key], FlatterDict):
out[key] = self._values[key].original_type()
else:
out[key] = self._values[key]
return out
def _child_as_list(self, pk, ck=None):
"""Returns a list of values from the child FlatterDict instance
with string based integer keys.
:param str pk: The parent key
:param str ck: The child key, optional
:rtype: list
"""
if ck is None:
subset = self._values[pk]
else:
subset = self._values[pk][ck]
# Check if keys has delimiter, which implies deeply nested dict
keys = subset.keys
if any(self._has_delimiter(k) for k in keys):
out = []
split_keys = {k.split(self._delimiter)[0] for k in keys}
for k in sorted(split_keys, key=lambda x: int(x)):
if subset[k].original_type == tuple:
out.append(tuple(self._child_as_list(pk, k)))
elif subset[k].original_type == list:
out.append(self._child_as_list(pk, k))
elif subset[k].original_type == set:
out.append(set(self._child_as_list(pk, k)))
elif subset[k].original_type == dict:
out.append(subset[k].as_dict())
return out
return [subset[k] for k in keys]
def my_function():
value_1 = "devsheet"
value_2 = 100
value_3 = ["item 1", "item 2"]
return value_1, value_2, value_3;
value_1, value_2, value_3 = my_function()
print(value_1)
print(value_2)
print(value_3)
try:
result = 3/0 #this will throw error
except Exception as e:
print("Repr : " + repr(e)) # Use repr to get error
print("Error : " + str(e)) # Use str to get error
try:
some_undefined_method()
except Exception as e:
print("Repr Error : " + repr(e))
print("Error : " + str(e))
else:
print("Program Executed successfully")
finally:
print("Finally always executes")
#Using else with for loop
for i in range(4):
print(i)
else: # Will execute after loop completed if no break statement
print("I am in else")
#else will not be executed if 'break' executed used inside loop
for item in ['one', 'two', 'three']:
if item == 'two':
break
print(item)
else:
print("This will not be executed")
def factorial(x):
if x == 1:
return 1
else:
return (x * factorial(x-1))
num = 4
print("The factorial of", num, "is", factorial(num))
import re
def validate_email(email):
email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
if ( re.fullmatch(email_pattern, email) ):
print("Email is Valid")
else:
print("Email is Invalid")
validate_email("test@domain.com")
# -> prints - Email is Valid
validate_email("testdomain.com")
# -> prints - Email is Invalid
IntegrationRequirement.objects.bulk_create(objs=objs, ignore_conflicts=True)
my_str = " This string contains spaces. "
#trim python string using strip() method
trimmmed_str = my_str.strip()
print(trimmmed_str)
#remove leading(beginning) whitespace
lstr = my_str.lstrip()
#remove trailing(end) whitespace
rstr = my_str.rstrip()
try:
obj = Person.objects.get(first_name='John', last_name='Lennon')
except Person.DoesNotExist:
obj = Person(first_name='John', last_name='Lennon', birthday=date(1940, 10, 9))
obj.save()
#shortcut for the above code
obj, created = Person.objects.get_or_create(
first_name='John',
last_name='Lennon',
defaults={'birthday': date(1940, 10, 9)},
)
fruits_list = ["Apple", "Orange", "Banana", "Pineapple"]
#using enumerate() method
for index, value in enumerate(fruits_list):
print(index, value)
#using range() method
for index in range(len(fruits_list)):
print(index, fruits_list[index])
#reverse a number
my_num = 12345
reversed_num = str(my_num)[::-1]
print(reversed_num)
# -> 54321
#reverse a string
my_str = "hello"
reversed_str = my_str[::-1]
print(reversed_str)
# -> olleh
subjects = ["Math", "Physics", "Chemistry", "English"]
last_item = subjects[-1]
print(last_item)
# prints - English
my_car = {
"name": "Nexon",
"brand": "TATA",
"color": "Green"
}
del my_car['color']
print(my_car)
fruit_list = []
# Using not keyword
if not fruit_list:
print("List is empty")
# Using len() method
if len(fruit_list) == 0:
print("List is empty")
my_list = ["one", "two", "three", "four", "five"]
# Using for loop
for item in my_list:
print(item)
# Using range by getting list length
for i in range(len(my_list)):
print(my_list[i])
all_filters = [UserModal.role == 'admin']
if user.last_name:
all_filters.append(UserModal.last_name == 'Deo')
db.session.query(
UserModal.username
).filter(
**all_filters
).all()
user_info = {
"name": "John",
"email": "test@test.com"
}
address_info = {
"city": "New York",
"country": "USA"
}
#Merge using .update() method
user_info.update(address_info)
print(user_info);
#Merge using ** operator
merged = {**user_info, **address_info}
print(merged)
def update(self, instance, validated_data):
for attr, value in validated_data.items():
setattr(instance, attr, value)
instance.save()
return instance
db.session.query(
UserModel.city
).distinct().all()
class ContactCompanySerializer(serializers.ModelSerializer):
# profile=ProfileSerializer()
# array şeklinde gönderiyoruz. Array içindekiler de charfield yani string.
integration_requirements = serializers.ListSerializer(
child=serializers.CharField())
class Meta:
model = ContactCompany
fields = ('id', 'name', 'website', 'country', 'city',
'address', 'sector', 'note', 'profile',
'integration_requirements')
# exclude_fields = ('created_at', 'updated_at', 'is_active')
# create methodunu override ediyoruz.
def create(self, validated_data):
# integration requirements kısmını validatet datadan çekiyoruz (array olarak).
integration_requirements = validated_data.pop(
'integration_requirements', [])
# company objemizi oluÅŸturuyoruz ve IntegrationRequirement modelinden
# post requestte gönderdiğimiz requirementleri filtreliyoruz.
company = super().create(validated_data)
integration_requirements_qs = IntegrationRequirement.objects.filter(
requirement__in=integration_requirements)
# Company'e direkt olarak requirementsleri ekliyoruz.
company.integration_requirements.add(*integration_requirements_qs)
return company
from rest_framework import serializers
class BlogPostSerializer(serializers.Serializer):
title = serializers.CharField(max_length=100)
content = serializers.CharField()
def validate_title(self, value):
"""
Check that the blog post is about Django.
"""
if 'django' not in value.lower():
raise serializers.ValidationError("Blog post is not about Django")
return value
fruits = "Apple,Mango,Orange"
fruit_list = fruits.split(',')
print( tuple(fruit_list) )
# -> ('Apple', 'Mango', 'Orange')
session.query(
MyModelname
).filter(
MyModelname.id.in_((10,11,12,13))
).all()
# Packages
import os
from google.cloud import bigquery
from google.oauth2 import service_account
# Parameters
os.environ["GOOGLE_APPLICATION_CREDENTIALS"]='/Users/jmbenedetto/Library/Mobile Documents/com~apple~CloudDocs/#Formação/Dissertation/Research/02 Research v2/00 Base/key.json'
client = bigquery.Client(project=project_name)
dataset_ref = client.dataset(dataset_name)
load_config = bigquery.LoadJobConfig()
# Code
query = """
DELETE
FROM dataset_name.table_name
WHERE criteria;
"""
query_params = [
bigquery.ArrayQueryParameter("file", "STRING", file_source)
]
job_config = bigquery.QueryJobConfig()
job_config.query_parameters = query_params
query_job = client.query(
query,
# Location must match that of the dataset(s) referenced in the query.
location="EU",
job_config=job_config,
) # API request - starts the query
query_job.result(timeout=60.0)
assert query_job.state == "DONE"
query="""
UPDATE datalab.jmb_deliveries
SET ot_client_order_ind = CASE
WHEN delivery_date>promise_date THEN 0
ELSE 1
END
WHERE
client_order_ind = 1
"""
query_job = client.query(
query,
# Location must match that of the dataset(s) referenced in the query.
location="EU"
)
query_job.result(timeout=120)
import json
my_dict = {
"id": 1,
"name": "Robert Downey Jr.",
"nick_name": "Iron Man",
"city": "New York"
}
json_str = json.dumps(my_dict)
print(json_str)
# -> "{"id": 1, "name": "Robert Downey Jr.", "nick_name": "Iron Man", "city": "New York"}"
import json
#Convert object to python dict
json_str = '{"id": 1, "name": "Suman Kumar", "city": "Delhi"}'
my_dict = json.loads(json_str)
print(my_dict["id"])
print(my_dict["name"])
print(my_dict["city"])
# -> 1
# -> Suman Kumar
# -> Delhi
#Convert to python list of dictionaries
json_str = """[
{"id": 1, "name": "Suman Kumar"},
{"id": 2, "name": "Gaurav"},
{"id": 3, "name": "John"}
]"""
my_list = json.loads(json_str)
print(my_list[1])
# -> prints {'id': 2, 'name': 'Gaurav'}
import math
#First Method - No need to import math module
number = 8
sq_root = number ** 0.5
print(sqrt)
#Second Method - Using math.sqrt() method
sq_root = math.sqrt(number)
print(sq_root)
#Third Method - Using math.pow() method
sq_root = math.pow(number, 0.5)
print(sq_root)
import random
final_list = random.sample(range(70), 15)
print(final_list)
import random
print (random.randint(1,50))
#It will print a random number between 1 to 50
print (random.random())
#It will print a Float random number between 0 to 1
print(random.sample( range(5, 24), 7) )
# Prints a list of 7 random numbers between 5 to 24
import pandas as pd
df = pd.DataFrame({
'Name': ['John', 'Eric', 'Rick'],
'Score': [200, 500, 100\]
})
df_columns = df.columns.values.tolist()
print(df_columns)
#prints - ['Name', 'Score']
import pandas as pd
df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
index=[1, 2, 3], columns=['A', 'B', 'C'])
#index - 3, column_name - 'C'
value = df.at[3, 'C']
print(value) # prints - 30
#this can also written as
value = df.loc[3].at['C']
print( value ) # prints - 30
import pandas as pd
df = pd.DataFrame({
'column_1': ['John', 'Eric', 'Rick'],
'column_2': [100, 110, 120]
})
for index, row in df.iterrows():
print(row['column_1'], row['column_2'])
#prints
# John 100
# Eric 110
# Rick 120
import pandas as pd
#first method - create empty dataframe
df = pd.DataFrame()
# append columns and rows to this dataframe
df['username'] = ['john', 'neil', 'curtis']
df['status'] = ['active', 'disabled', 'active']
print(df)
#----------------------------------------------------------------------------------#
#second method - create dataframe with columns
df = pd.DataFrame(columns = ['username', 'status'])
# append rows to the abo
df = df.append({'username' : 'john', 'status' : 'active'}, ignore_index = True)
df = df.append({'username' : 'neil', 'status' : 'disabled'}, ignore_index = True)
df = df.append({'username' : 'curtis', 'status' : 'active'}, ignore_index = True)
print(df)
#----------------------------------------------------------------------------------#
#make data frame with rows having - NaN values at index - a, b and c
df = pd.DataFrame(columns = ['username', 'status'], index = ['a', 'b', 'c'])
print(df)
# +---+----------+--------+
# | | username | status |
# +---+----------+--------+
# | a | NaN | NaN |
# | b | NaN | NaN |
# | c | NaN | NaN |
# +---+----------+--------+
# add rows at already created indexes
df.loc['a'] = ['john', 'active']
df.loc['b'] = ['neil', 'disabled']
df.loc['c'] = ['curtis', 'active']
print(df)
import pandas as pd
my_dict = [{'Name': 'John', 'Score': 20}, {'Name': 'Mark', 'Score': 50}, {'Name': 'Rick', 'Score': 70}]
df = pd.DataFrame.from_dict(my_dict)
print(df)
# +----+--------+---------+
# | | Name | Score |
# +-------------+---------+
# | 0 | John | 20 |
# | 1 | Mark | 50 |
# | 2 | Rick | 70 |
# +----+--------+---------+
a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
print(a)
my_str = "Hello World!"
print( my_str.lower() )
#prints - hello world
import pandas as pd
df_fruits = pd.DataFrame()
df_fruits["fruit_name"] = ["Orange", "Banana", "Apple"]
df_fruits["color"] = ["orange", "yellow", "red"]
print(df_fruits.to_dict('records'))
# prints - [{'fruit_name': 'Orange', 'color': 'orange'}, {'fruit_name': 'Banana', 'color': 'yellow'}, {'fruit_name': 'Apple', 'color': 'red'}]
import pandas as pd
df = pd.DataFrame()
df["Name"] = ["John", "Mark", "Rick"]
df["Score"] = [20, 50, 70]
print(df.to_dict())
# prints - {'Name': {0: 'John', 1: 'Mark', 2: 'Rick'}, 'Score': {0: 20, 1: 50, 2: 70}}
print(df.to_dict('split'))
# prints - {'index': [0, 1, 2], 'columns': ['Name', 'Score'], 'data': [['John', 20], ['Mark', 50], ['Rick', 70]]}
print(df.to_dict('records'))
# prints - [{'Name': 'John', 'Score': 20}, {'Name': 'Mark', 'Score': 50}, {'Name': 'Rick', 'Score': 70}]
print(df.to_dict('index'))
#prints - {0: {'Name': 'John', 'Score': 20}, 1: {'Name': 'Mark', 'Score': 50}, 2: {'Name': 'Rick', 'Score': 70}}
users = [
{ "name": "John Deo", "username": "john01" },
{ "name": "Stephen Hawk", "username": "stephen" },
{ "name": "Rick Grimes", "username": "rick21" }
]
names = [d["name"] for d in fruits] #returns list
print(names)
#prints - ["John Deo", "Stephen Hawk", "Rick Grimes"]
names_comma_seperated = ','.join( [d["title"] for d in data['current']] )
print(names_comma_seperated)
#prints - John Deo,Stephen Hawk,Rick Grimes
#dictionary - user
user = {
"name": "John",
"email": "mail@domain.com"
}
#check using has_key
if user.has_key('email'):
print("email key exists in the dictionary")
else:
print("email key does not exist")
#check using in
if 'email' in user:
print "email key exists"
else:
print "email key does not exist"
import requests
raw_json_data = { "user_name": "hello", "password": "password1" }
data = { "first_name": "hello", "last_name": "world" }
headers = { 'Authorization': 'Bearer token_value_here' }
response = requests.post('https://path/to/api/url/endpoint', headers = headers, data = data, json=raw_json_data)
print(response.status) #prints the status of request
print(response.content) #prints the content
print(response.json()) #json formatted data if response returns any
user_input = input("MESSAGE YOU WANT TO SHOW : ")
print(user_input)
# load all models
import os
curr_dir = os.path.abspath('.')
os.chdir('/home/jupyter/model-api/')
try:
import networks as main
model = main.Networks()
finally:
os.chdir(curr_dir)
from sqlalchemy import and_
session.query(
UserModel.id,
UserModel.first_name
).filter(
and_(
UserModel.first_name == 'john',
UserModel.last_name == 'michael'
)
).all()
for char in "orange":
print(char)
my_str = "The world is beautiful"
print(len(my_str)) #prints 22
my_str = "We are here to help"
print(my_str[4]) #prints 'r'
print(my_str[7]) #prints 'h'
user_counts = session.query(
UserModel.role,
func.count(UserModel.role).label("total_counts")
).group_by(
UserModel.role
).all()
#THE ABOVE QUERY CAN OUTPUT DATA:
# +-------------+----------------+
# | role | total_counts |
# +-------------+----------------+
# | Admin | 100 |
# | Super Admin | 50 |
# | user | 1700 |
# +-------------+----------------+
from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, Integer, String
from datetime import datetime
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
username = Column(String, nullable=False)
firstname = Column(String)
lastname = Column(String, nullable=True, default='')
created_date = db.Column(db.DateTime, default=datetime.now())
def __repr__(self):
return "<User(username='%s', firstname='%s', lastname='%s')>" % (self.username, self.firstname, self.lastname)
employees = EmployeeModel\
.query\
.order_by(EmployeeModel.id.desc())\
.paginate(
page=1,
per_page=10,
max_per_page=10,
error_out=False
)
result = {
"total_records": employees.total,
"page": employees.page,
"items": employees.items
}
from sqlalchemy import text
class User_Model(db.Model):
#use server_default if table already created to add default value
flag = db.Column(db.Boolean, nullable=False, server_default=text('1'))
from sqlalchemy import func
# SYNTAX - func.coalesce(model.prop, default_value)
db.session.query(
UserModel.id,
func.coalesce(UserModel.active, false).label('is_active'),
).filter(
UserModel.status == 'active'
).all()
from sqlalchemy import or_
dbsession.query(
EmployeeModel
).filter(
or_(
EmployeeModel.status != 'active',
EmployeeModel.status == None #this is used to check NULL values
)
).all()
from sqlalchemy import or_, and_
#USING AND CONDITION
session.query(
EmployeeModel.name,
EmployeeDepartment.dept_name
).join(
EmployeeDepartment,
and_(
EmployeeDepartment.employee_id == EmployeeModel.id,
EmployeeDepartment.dept_code == 'P01'
)
).all()
#USING OR CONDITION
session.query(
EmployeeModel.name,
EmployeeDepartment.dept_name
).join(
EmployeeDepartment,
or_(
EmployeeDepartment.employee_id == EmployeeModel.id,
EmployeeDepartment.dept_code == 'P01'
)
).all()
self.session.query(
UserModel.id,
UserModel.username.label("name")
UserModel.email
).outerjoin(
UserContactModel,
and_(
UserModel.is == UserContactModel.user_id,
UserContactModel.country == 'india'
)
).filter(UserModel.role == 'user').all()
#Direct apply on model property
.order_by(UserModel.id.desc())
#by importing desc() method
from sqlalchemy import desc
session.query(UserModel).order_by(desc(UserModel.id)).all()
employees = self.session.query(
EmployeeModel.id,
EmployeeModel.name.label("emp_name") #we are using emp_name alias for column name
).filter(
EmployeeModel.department == 'finance'
).all()
session.query(
UserModel
).filter(
UserModel.id == 20
).update({
UserModel.username: 'john_deo',
UserModel.email: 'johndeo@domain.com',
UserModel.city: 'New York'
})
session.commit()
self.session.query(
UserModel
).filter(
UserModel.id == 100
).delete(synchronize_session=False)
self.session.commit()
from sqlalchemy import or_
session.query(
UserModel.id,
UserModel.first_name
).filter(
or_(
UserModel.username == 'john',
UserModel.username == 'michael'
)
).all()
session.query(
Employee_Model.first_name,
Employee_Model.last_name,
Employee_Model.email,
Employee_Address_Model.address
).join(
Employee_Address_Model,
Employee_Address_Model.employee_id == Employee_Model.id,
isouter = True #Add this to implement left outer join
).all()
def outliers(column):
Q1, Q3 = np.percentile(column, [25, 75])
IQR = Q3 - Q1
lower_range = Q1 - (1.5 * IQR)
upper_range = Q3 + (1.5 * IQR)
return lower_range, upper_range
outliers(df['yearly_salary'])
my_str = "This is a string"
print(my_str.split())
#output - ["This", "is", "a", "string"]
comma_str = "Apple, Banana, Orange"
print(comma_str.split(", "))
#output - ["Apple", "Banana", "Orange"]
Integer #integer type
SmallInteger #Small integer type
BigInteger #Big integer type
String #all string and character types
Text #variably sized string type
Boolean #Bool data type
Float #floating point data type
Enum #Generic Enum Type
Date #data type for datetime.date() objects
DateTime #data type for datetime.datetime() objects
Interval #data type for datetime.timedelta() objects
LargeBinary #large binary byte data
PickleType #Holds Python objects, which are serialized using pickle
Time #data type for datetime.time() objects
#record has 'test' keyword on any position
session.query(User).filter(User.first_name.like('%test%')).all()
#record has 'test' keyword on first position
session.query(User).filter(User.first_name.like('test%')).all()
#record has 'test' keyword on last position
session.query(User).filter(User.first_name.like('%test')).all()
#get all records of first_name column
self.session.query(User.first_name).all()
#Get vey first record from a table which has id grater than 10
session.query(User).filter(User.id > 10).first()
#JOINING TABLE (User and Address)
self.session.query(
User.id,
User.first_name,
User.last_name,
Address.city,
Address.State
).join(
Address, User.id == Address.user_id
).filter(
Address.city.like('new%'))
).all()
#SINGLE CONDITION
session.query(User).filter(User.id == 10).all()
#MULTIPLE CONDITION
session.query(User).filter(User.first_name == 'hello', User.last_name == 'world').first()
#LIKE QUERY
session.query(User).filter(User.name.like('e%')).all()
df.to_excel("~/Desktop/folder-name/filename.xlsx")
dframe = dframe[['column 5','column 6',4,3,2,1]]
from database import db, Base
from marshmallow import Schema, fields
from datetime import datetime as date
class Employee(db.Model):
__tablename__ = "employee"
id = db.Column(db.Integer, primary_key=True, autoincrement=True, mssql_identity_start=100000)
employee_uid = db.Column(db.Integer, unique=True)
employee_email = db.Column(db.String, nullable=False)
employee_name = db.Column(db.String(200), nullable=True)
created_on = db.Column(db.DateTime, default=date.now())
class EmployeeAddress(db.Model):
__tablename__ = "employee_address"
id = db.Column(db.Integer, primary_key=True, autoincrement=True, mssql_identity_start=100000)
employee_id = db.Column(db.Integer, db.ForeignKey('employee.id'), nullable=False)
employee = db.relationship('Employee')
employee_address = db.Column(db.Text, nullable=False)
flask db stamp head
flask db migrate
flask db upgrade
#SORT DICTIONARY ITEMS
my_subjects = {
"math": { "sub_code": "M001", "score": 60 },
"physics": { "sub_code": "P001", "score": 40 },
"chemistry": { "sub_code": "C001", "score": 50 },
"english": { "sub_code": "E001", "score": 45 }
}
#SORT DATA ASCENDING ORDER
sorted_data_asc = sorted( my_subjects.items(), key = lambda x: x[1]['score'] )
print(dict(sorted_data_asc))
#SORT DATA DESCENDING ORDER
sorted_data_desc = sorted( my_subjects.items(), key = lambda x: x[1]['score'], reverse=True )
print(dict(sorted_data_desc))
#SORT A LIST OF DICTIONARIES
my_list = [
{"name": "John", "score": 30},
{"name": "Deep", "score": 10},
{"name": "Mark", "score": 50}
]
list_asc = sorted(my_list, key = lambda i: i['score'])
print (list_asc)
list_desc = sorted(my_list, key = lambda i: i['score'], reverse=True)
print (list_desc)
my_score = {
"math": 90,
"physics": 80,
"chemistry": 85,
"english": 91
}
#TO REMOVE 'physics' kEY from my_score
del my_score['physics']
condition_value = 1
val = 1 if condition_value == 1 else 2
print val
def hellPrint():
myvar = "1"
message = "Condition is true" if myvar == "1" else "Condition is false"
print(message)
hellPrint()
In [1]: import torch
In [2]: torch.cuda.current_device()
Out[2]: 0
In [3]: torch.cuda.device(0)
Out[3]: <torch.cuda.device at 0x7efce0b03be0>
In [4]: torch.cuda.device_count()
Out[4]: 1
In [5]: torch.cuda.get_device_name(0)
Out[5]: 'GeForce GTX 950M'
In [6]: torch.cuda.is_available()
Out[6]: True
@xw.func
@xw.ret(expand = "table")
def randomstd(mean, std, rows, columns):
return np.random.normal(mean, std, (int(rows), int(columns)))
xlwing　使用
テã‚ストファイルã®ä¸èº«
test.txt
テスト　test t3 USD 44
te 55 99 gbe 99
pythonファイル
hello.py
def import_txt_split():
# ブックã®èªã¿è¾¼ã¿
wb = xw.Book.caller()
# シートã®èªã¿è¾¼ã¿
sht = wb.sheets['Sheet1']
# テã‚ストファイルã®èªã¿è¾¼ã¿
f = open('test.txt', 'r',encoding='UTF-8')
# å„行をリストã§å–å¾—
datalist = f.readlines()
# 空白をå–り除ã
s = [i.split() for i in datalist]
# 1è¡Œãšã¤ã€ãƒªã‚¹ãƒˆã‚’ペッã¨è²¼ã‚Šä»˜ã‘ã‚‹
for num,i in enumerate(s):
sht.cells(num+1,1).value = i
# テã‚ストファイルを閉ã˜ã‚‹
f.close()
VBAå´
Sub import_text()
RunPython ("import hello; hello.import_txt_split()")
End Sub
ã“ã®VBAをボタンã«ãƒžã‚¯ãƒç™»éŒ²ã€‚クリック
çµæžœ
qita1.png
上記ã®æ–¹æ³•ä»¥å¤–ã«ã€pandasã®dataframeã«è²¼ã‚Šä»˜ã‘ã¦ã€A1セルã«ãºã£ã¨è²¼ã‚Šä»˜ã‘る方法ã§ã‚‚出æ¥ãŸ
python manage.py db init #INITIALIZE NEW MIGRATION
python manage.py db migrate #TO CREATE MIGRATION
python manage.py db upgrade #APPLY MIGRATION CHANGES ON DB
#import Pynput library
import Pynput
#import mouse from pynput
from pynput import mouse
#import controller from mouse
from pynput.mouse import Controller
mouse = Controller()
print(mouse.position)
#SIMPLE FUNCTION
def function_name():
print("Hello world")
function_name() #CALL FUNCTION
# FUNCTION WITH ARGUMENTS
def function_with_args(first_name, last_name):
print("First name is " + first_name + ". Last name is" + last_name)
function_with_args("John", "Deo") #CALL FUNCTION WITH ARGUMENTS
#CALL WITH KEYWORDS ARGUMENTS
#ARGUMENT ORDER DOES NOT MATTER
function_with_args(last_name = "Deo", first_name = "John")
#WITH ARBITARY ARGUMENTS
#USE WHEN NUMBER OF ARGUMENT PASSED IS UNKNOWN
def function_with_arbitary_args(*args):
print("Third item is " + args[2])
function_with_arbitary_args("Bat", "Bowl", "Hockey") #WILL PRINT 'HOCKEY'
#WITH ARBITARY KEYWORD ARGUMENTS
def function_with_arbitary_args(*args):
print("Third item is " + args["last_name"])
function_with_arbitary_args(first_name = "Rick", last_name = "Bowl")
counter = 1
while counter < 6:
print(counter)
counter += 1
#WITH ELSE STAEMENT
while counter < 6:
print(counter)
counter += 1
else:
print("counter is greater or equals to 6");
from os import listdir
from os.path import isfile, join
dirPath = "path/to/my/directory"
allFileAndFolders = listdir(dirPath)
allFiles = [f for f in allFileAndFolders if isfile(join(dirPath, f))]
val = 12.89
val1 = round(val, 0)
val2 = round(val, 1)
print(val1)
print(val2)
# 13.0
# 12.9
float_val = 12.98;
print( int(float_val) );
# 12
# pip install moviepy
# pip install imageio-ffmpeg
from moviepy.video.io.ffmpeg_tools import ffmpeg_extract_subclip
ffmpeg_extract_subclip("path/to/full/video.mp4", 30, 100, targetname="path/to/final/video.mp4")
# 30 - start second
# 100 - end second
from moviepy.editor import VideoFileClip, concatenate_videoclips
video_1 = VideoFileClip("path/to/first/video.mp4")
video_2 = VideoFileClip("path/to/second/video.mp4")
final_video= concatenate_videoclips([video_1, video_2], method="compose")
final_video.write_videofile("path/to/final/video.mp4")
import os
import boto3
from botocore.exceptions import ClientError
client = boto3.client(
's3',
# Hard coded strings as credentials, not recommended.
aws_access_key_id='',
aws_secret_access_key=''
)
s3 = boto3.resource(
's3',
# Hard coded strings as credentials, not recommended.
aws_access_key_id='',
aws_secret_access_key=''
)
# print(bucket_subfolder)
bucket = 'bucket-name'
for my_bucket_object in s3.Bucket(bucket).objects.all():
print(my_bucket_object)
test_url = 'http://httpbin.org/status/404'
pyrcc5 -o resources.py resources.qrc
intVal = 10
strVal = str(intVal)
class MyDialog(QtWidgets.QDialog):
def __init__(self):
super(MyDialog, self).__init__()
self.setFixedSize(640, 480)
tuple1 = (1, 2, 3, 4)
tuple2 = (5, 6, 7, 8)
tuple3 = tuple1 + tuple2
print(tuple3)
class Cheese(object):
def __init__(self, num_holes=0):
"defaults to a solid cheese"
self.number_of_holes = num_holes
@classmethod
def random(cls):
return cls(randint(0, 100))
@classmethod
def slightly_holey(cls):
return cls(randint(0, 33))
@classmethod
def very_holey(cls):
return cls(randint(66, 100))
# Now create object like this:
gouda = Cheese()
emmentaler = Cheese.random()
leerdammer = Cheese.slightly_holey()
# another example
class C(object):
def __init__(self, fd):
# Assume fd is a file-like object.
self.fd = fd
@classmethod
def fromfilename(cls, name):
return cls(open(name, 'rb'))
# Now you can do:
c = C(fd)
# or:
c = C.fromfilename('a filename')
#store variables
%store stream_whole
#read variables
%store -r stream_whole
class Product(object):
def __init__(self, price = 0.0, name = ""):
self.price = price
self.name = name
# property for __price attribute
@property
def price(self):
return self.__price
@price.setter
def price(self, value):
if value < 0:
raise ValueError("Price cannot be negative")
self.__price = value
# property for __name attribute
@property
def name(self):
return self.__name
@name.setter
def name(self, value):
for ch in value:
if ch.isdigit():
raise Exception("Enter valid product name")
self.__name = value
# Use custom separator sep
df.to_csv('file_name.csv',sep='\t')
# Write without index index
df.to_csv('file_name.csv',index=False)
# Write without headers header
df.to_csv('file_name.csv',header=False)
# Write subset of columns columns
df.to_csv('file_name.csv',columns=['col_A','col_B'])
# Change file encoding format encoding
df.to_csv('file_name.csv',encoding='utf-8')
# Change NaNs as Unknown na_rep
df.to_csv('file_name.csv',na_rep='Unknown')
print("This the second example")
pip freeze > requirements.txt
import pathlib # 標準ライブラリ
import openpyxl # 外部ライブラリ　pip install openpyxl
import csv # 標準ライブラリ
# ワークブックを作æˆ
new_workbook = openpyxl.Workbook()
# デフォルトã§ä½œæˆã•ã‚Œã‚‹ãƒ¯ãƒ¼ã‚¯ã‚·ãƒ¼ãƒˆã‚’é¸æŠž
new_sheet = new_workbook.active
new_row = 1
# ..\ → ã“ã®ãƒ—ãƒã‚°ãƒ©ãƒ ã®è¦ªãƒ•ã‚©ãƒ«ãƒ€ã‚’示ã™ã€‚(.\ã ã‘ã ã¨ã‚«ãƒ¬ãƒ³ãƒˆãƒ•ã‚©ãƒ«ãƒ€ã‚’示ã™ã€‚)
path = pathlib.Path("..\data\targetfolder") #相対パス指定
# path.iterdir()　→　ディレクトリ内ã®ãƒ•ã‚¡ã‚¤ãƒ«ãƒ»ã‚µãƒ–ディレクトリ一覧をå–å¾—
for all_obj in path.iterdir():
# æ‹¡å¼µåãŒxlsxã‹ã‚’判定
if all_obj.match("*.xlsx"):
# ワークブックã®èªã¿è¾¼ã¿ã€€ã€€//最åˆã‹ã‚‰globを使用ã™ã‚Œã°ã„ã„ã®ã§ã¯ï¼Ÿ
wb = openpyxl.load_workbook(all_obj)
# ワークブックã‹ã‚‰ã‚·ãƒ¼ãƒˆã‚’é †ã«èªã¿è¾¼ã¿
for target_sheet in wb:
#シートã®9行目ã‹ã‚‰18行目ã¾ã§ã‚’æ“作ã™ã‚‹ã‚ˆã†ã«æŒ‡ç¤º //xlupã®ã‚ˆã†ã«å§‹ã¾ã‚Šã¨çµ‚ã‚ã‚ŠãŒåˆ†ã‹ã‚‰ãªã„å ´åˆã«å¯¾å¿œã•ã›ã‚‹ã«ã¯ï¼Ÿ
for target_row in range(9,19):
# 対象行ã®2番目ã®åˆ—ã«ã€ãƒ‡ãƒ¼ã‚¿ãŒå…¥åŠ›ã•ã‚Œã„ã‚‹ã‹ã‚’調ã¹ã‚‹ã€‚
if target_sheet.cell(target_row, 2).value != None:
#より説明的ãªã‚³ãƒ¼ãƒ‰
#new_sheet.cell(row=new_row, column=1).value = \
# target_sheet.cell(row=2, column=7).value #ä¼ç¥¨NO
#対象ファイルã®2行目7列目をã€ä½œæˆã—ãŸã‚·ãƒ¼ãƒˆã®å¯¾è±¡è¡Œã®list_row行目ã®1列目ã«è»¢è¨˜
new_sheet.cell(new_row, 1).value = target_sheet.cell(2, 7).value #ä¼ç¥¨NO
# 以下åŒæ§˜ã®è€ƒãˆ
new_sheet.cell(new_row, 2).value = target_sheet.cell(3, 7).value #日付
new_sheet.cell(new_row, 3).value = target_sheet.cell(4, 3).value #å¾—æ„先コード
new_sheet.cell(new_row, 4).value = target_sheet.cell(7, 8).value #担当者コード
#対象ファイルã®dt_row行目ã®1列目をã€ä½œæˆã—ãŸã‚·ãƒ¼ãƒˆã®list_row行目ã®1列目ã«è»¢è¨˜
new_sheet.cell(new_row, 5).value = target_sheet.cell(target_row, 1).value #No
#以下åŒæ§˜
new_sheet.cell(new_row, 6).value = target_sheet.cell(target_row, 2).value #商å“コード
new_sheet.cell(new_row, 7).value = target_sheet.cell(target_row, 3).value #商å“å
new_sheet.cell(new_row, 8).value = target_sheet.cell(target_row, 4).value #æ•°é‡
new_sheet.cell(new_row, 9).value = target_sheet.cell(target_row, 5).value #å˜ä¾¡
# 「\〠→　行継続ã®è¨˜å·
# 対象ファイルã®dt_row行目ã®4列目ã¨5列目ã®ç©ã‚’ã€ä½œæˆã—ãŸã‚·ãƒ¼ãƒˆã®list_row行目ã®ï¼‘ï¼åˆ—ç›®ã«è»¢è¨˜
new_sheet.cell(new_row, 10).value = target_sheet.cell(target_row, 4).value * \
target_sheet.cell(target_row, 5).value #金é¡
new_sheet.cell(new_row, 11).value = target_sheet.cell(target_row, 7).value #備考
# æ–°ã—ã„データ下ã«è¿½åŠ ã§ãるよã†ã«ã€list_rowã«1ã‚’åŠ ç®—
new_row += 1
#new_workbook.save("..\data\sales\salesList.xlsx")
# ファイルã®ä¿å˜
# 引数ã¨ã—ã¦ã€ãƒ•ã‚¡ã‚¤ãƒ«åã€ãƒ¢ãƒ¼ãƒ‰ã€ã‚¨ãƒ³ã‚³ãƒ¼ãƒ‡ã‚£ãƒ³ã‚°ã‚’指定
with open("..\newList.csv","w",encoding="utf_8_sig") as fp:
writer = csv.writer(fp, lineterminator="\n")
# 作æˆã—ãŸã‚·ãƒ¼ãƒˆã®å„行をå–å¾—
for row in new_sheet.rows:
# å„è¡Œã‹ã‚‰å„列をå–り出ã—ã€ãƒªã‚¹ãƒˆã«ã™ã‚‹ã€‚
# ãã®1行分ã®ãƒªã‚¹ãƒˆã‚’writer.writerow()ã«ã‚ˆã‚Šã€csvã¨ã—ã¦å‡ºåŠ›ã™ã‚‹ã€‚
writer.writerow([col.value for col in row])
import re
import glob
import os
import shutil
import csv
# åŒãƒ•ã‚©ãƒ«ãƒ€å†…ã®htmlファイルåã‚’å–å¾—
file_name = glob.glob('*.csv')[0]
if "～" not in file_name:
print("実行ã™ã‚‹")
# ã“ã“ã«ã‚³ãƒ¼ãƒ‰ã‚’記述
f = open(file_name)
reader = csv.reader(f)
l = [row for row in reader]
beginning=l[1][0]
ending=l[-1][0]
beginning.split("/")
start_date=beginning.split("/")[2] + "-" + beginning.split("/")[0] + "-" + beginning.split("/")[1]
ending.split("/")
end_date=ending.split("/")[2] + "-" + ending.split("/")[0] + "-" + ending.split("/")[1]
start_date + "～" + end_date
new_file_name=file_name.replace("FromDownloader","")
new_file_name=new_file_name.replace("_BidAndAsk","")
new_file_name = new_file_name + "["+start_date + "～" + end_date+"]"
f.close()
os.rename(file_name,new_file_name)
else:
print("実行ã—ãªã„")
text = "barabrara M30 (2003.11.01 - 2019.12.01) brarbrarbab"
re.findall(r'[A-Z][0-9]+ \([0-9]+\.[0-9]+\.[0-9]+ - [0-9]+\.[0-9]+\.[0-9]+\)',text)[0]
pip install -r /path/to/requirements.txt
# osh シートオブジェクトåã¨ä»®å®š
def print_header():
osh["A1"].value = "担当者"
osh["B1"].value = "æ•°é‡"
osh["C1"].value = "金é¡"
osh["D1"].value = "å¾—æ„å…ˆ"
osh["E1"].value = "æ•°é‡"
osh["F1"].value = "金é¡"
# å‰æ
# スクレイピングã—ãŸãƒ‡ãƒ¼ã‚¿ã‚’results.pickleã¨ã„ã†ãƒ•ã‚¡ã‚¤ãƒ«åã§å–得済
import pandas as pd
# データã®èªã¿è¾¼ã¿
results=pd.read_pickle('results.pickle')
def preproccessing(results):
# å…ƒã®ãƒ‡ãƒ¼ã‚¿ã‚’変更ã—ãªã„ãŸã‚ã«ã€ã‚³ãƒ”ー
df = results.copy()
# ç€é †ã«æ•°å—以外ã®æ–‡å—列ãŒå«ã¾ã‚Œã¦ã„ã‚‹ã‚‚ã®ã‚’å–り除ã
df = df[~(df['ç€é †'].astype(str).str.contains("\D"))]
# æ•´æ•°åž‹ã«å¤‰æ›
df['ç€é †'] = df['ç€é †'].astype(int)
# 性齢を「性ã€ã€Œå¹´é½¢ã€ã«åˆ†ã‘ã‚‹
df['性'] = df['性齢'].map(lambda x:str(x)[0])
df['年齢'] = df['性齢'].map(lambda x:str(x)[1:]).astype(int)
# 馬体é‡ã‚’「体é‡ã€ã¨ã€Œä½“é‡å¤‰åŒ–ã€ã«åˆ†ã‘ã‚‹
df["体é‡"] = df["馬体é‡"].str.split('(', expand= True)[1].str[:-1].astype(int)
df["体é‡å¤‰åŒ–"] = df["馬体é‡"].str.split('(', expand= True)[1].str[:-1].astype(int)
# å˜å‹ã®åž‹ã‚’floatåž‹ã«å¤‰æ›
df['å˜å‹'] = df["å˜å‹"].astype(float)
# ä¸è¦ãªåˆ—を削除
df.drop(['タイム','ç€å·®','調教師','性齢','馬体é‡'],axis=1,inplace=True)
return df
my_dict = {
"first_name": "John",
"last_name": "Deo",
"occupation": "programmer"
}
print(my_dict["first_name"]) #print first_name value of dictionary
print(my_dict.get("first_name")) #same as above
my_dict["first_name"] = "Josef" #To change first_name value
my_dict.values() #return values of dictionary
my_dict["nick_name"] = "JDo" #To add key value to dictionary
my_dict.pop("last_name") #To remove a key value pair from dictionary based on key
del my_dict["last_name"] #Same as above
my_dict.clear() #empty a dictionary
my_dict.copy() #To copy a dictionary
my_set = {"item_1", "item_2", "item_3"}
"""
sets are unordered and unindexed
so it can not be accessed by using index
"""
for (item in my_set):
print(item)
my_set.add("item_4") #To add single item to set
my_set.update(["item_4", "item_5"]) #To add multiple items to set
my_set.remove("item_3") #To remove an item
del my_set #To remove set
#Tuples are unchangable means you can not modify its items
fruits = ("banana", "orange", "apple", "grapes")
print(fruits[2]) #print third element apple
print(fruits[:3]) #print items start index to 0 and less than index 3
print(fruits[1:3]) #print tuple start from index 1 and less than index 3
print(fruits[-1]) #print last element
import pandas as pd
import time
# プãƒã‚°ãƒ¬ã‚¹ãƒãƒ¼ã®è¡¨ç¤º
from tqdm import tqdm_notebook as tqdm
# 対象ã®urlã®æ§‹é€ 分æž
# 'https://db.netkeiba.com/race/202006030301'
# ex.
# 202006030301ã«ã¤ã„ã¦
# 2020 → 西暦
# 06 → é–‹å‚¬å ´ã€€ï¼ˆ'æœå¹Œ', '函館', 'ç¦å³¶', '新潟', 'æ±äº¬', 'ä¸å±±', 'ä¸äº¬', '京都', '阪神', 'å°å€‰'）
# 03 → ä¸Šè¨˜é–‹å‚¬å ´ã®ä½•å›žç›®
# 03 → ä¸Šè¨˜é–‹å‚¬å ´ã®ä¸Šè¨˜å›žã®ä½•æ—¥ç›®
# 01 → レース番å·
race_id_list = []
# 開催上
for place in range(1,11,1):
# ～回
for kai in range(1,6,1):
# ～日
for day in range(1,9,1):
# ～R
for r in range(1,13,1):
race_id = "2019"+ str(place).zfill(2)+str(kai).zfill(2)+str(day).zfill(2) + str(r).zfill(2)
race_id_list.append(race_id)
# 途ä¸ä¸æ–ã—ã€å†é–‹ã—ãŸæ™‚を想定ã—ã€èªã¿è¾¼ã¿æ¸ˆã¿ã®çµæžœã‚’第２引数ã«
def scrape_race_results(race_id_list,pre_race_results={}):
# æ—¢ã«èªã¿è¾¼ã¿æ¸ˆã®çµæžœã‚’åæ˜
race_results = pre_race_results
# tqdmã«ã‚ˆã‚Šã€é€²æ—を表示ã•ã›ã‚‹
for race_id in tqdm(race_id_list):
# レースIDãŒèªã¿è¾¼ã¿æ¸ˆã®ãƒªã‚¹ãƒˆå†…ã«ã‚ã‚‹å ´åˆã¯ã€ã“ã“ã§å‡¦ç†ã‚’ä¸æ–ã—ã€foræ–‡ã¸æˆ»ã™
if race_id in race_results.keys():
print(race_id)
continue
try:
url = "https://db.netkeiba.com/race/" + race_id
race_results[race_id] = pd.read_html(url)[0]
time.sleep(1)
# 該当ã®IDã«ãƒ¬ãƒ¼ã‚¹æƒ…å ±ãŒãªã‹ã£ãŸå ´åˆã«ã‚‚ä¸æ–ã—ãªã„よã†ã«ã™ã‚‹ã€‚
except IndexError:
continue
# スクレイピング自体をä¸æ–ã—ã¦ã‚‚ã€race_resultsã‚’è¿”ã—ã¦ãれるよã†ã«ã™ã‚‹ã€‚
except:
break
return race_results
# テストä¸æ–ã—ã¦å®Ÿè¡Œã™ã‚‹ã¨ãã«ã€å·¦è¾ºã¨å³è¾ºã‚’ãã‚Œãžã‚Œï¼‘ãšã¤ãšã‚‰ã—ã¦å®Ÿè¡Œã™ã‚‹ï¼ˆex. test3 = ~ test2)
test2 = scrape_race_results(race_id_list,test)
# å–å¾—ã—ãŸå„レースã®çµæžœãƒ‡ãƒ¼ã‚¿ï¼ˆä»Šã¯è¾žæ›¸åž‹ã§ãã‚Œãžã‚Œåˆ†ã‹ã‚Œã¦ã„る）をã¤ãªã’る処ç†
# ã¤ãªã’ãŸéš›ã«è˜åˆ¥ã§ãるよã†ã«ã€IDをレースIDã«ã—ã¦ãŠã。
# å…¨ã¦ã®ãƒ¬ãƒ¼ã‚¹IDを一ã¤ãšã¤å–り出ã—ã€
for key in test.keys():
# å„ç€ç‰ˆã”ã¨ã«ã¤ã‘られã¦ã„るインデックスをレースIDã«å¤‰æ›ã€‚é•·ã•ã¯å„レースã®ãƒ‡ãƒ¼ã‚¿ãƒ•ãƒ¬ãƒ¼ãƒ ã®é•·ã•ï¼ˆé¦¬ã®æ•°ï¼‰åˆ†ã ã‘ç½®ãæ›ãˆã‚‹ã€‚
test[key].index = [key]*len(test[key])
# å…¨ã¦ã‚’ã¤ãªã’ã€ï¼‘ã¤ã®ãƒ‡ãƒ¼ã‚¿ãƒ•ãƒ¬ãƒ¼ãƒ ã«ã¾ã¨ã‚る。行ãŒå…¥ã‚Œæ›¿ã‚らãªã„よã†ã«sort=Falseã‚’è¨å®šã€‚
results = pd.concat([test[key] for key in test.keys()], sort=False)
# pickleå½¢å¼ã§ä¿å˜
results.to_pickle('results.pickle')
# csvã§ä¿å˜
results.to_csv("results.csv", encoding='utf_8_sig')
list = ["pen", "pencil", "sharpner", "eraser", "board"]
print(list[2]) #print third element sharpner
print(list[:3]) #print items start index to 0 and less than index 3
print(list[1:3]) #print list start from index 1 and less than index 3
print(list[-1]) #print last element
def favourite_fruit(*args):
print("My favourite fruit is : " + args[1])
favourite_fruit("Apple", "Mango", "Banana")
def function_name():
print("Hello this is a function")
#To call the above function use
function_name()
#LOOP THROUGH LIST
names = ["John", "Sonia", "Rakesh"]
for item in names:
print(item)
#LOOP THROUGH DICTIONARY
my_dict = {
"name": "John",
"title": "Programmer",
"lang": "Python"
}
for key in my_dict:
print(key, "is: ", my_dict[key])
# Loop through list of dictionaries
subjects = [
{ "name": "English", "score": 90 },
{ "name": "Math", "score": 100 },
{ "name": "Physics", "score": 90 }
]
for subject in subjects:
print("Subject Name is: ", subject['name'], " Score is: ", subject['score'])
x = 50
y = 30
if x > y:
print("x is greater than y")
elif x == y:
print("x equals to y")
else:
print("y is greater than x")
#Write comment text here
print("Hello World 1!")
print("Hello World 2!") #OR like this
"""
This is a multiline comment
You can add as much lines as you want
"""
print("Hello World 3!")
# masters_copy.py
import openpyxl
# 1) エクセルファイルを開ã
wb = openpyxl.load_workbook("sample.xlsx")
ws = wb["ä½æ‰€"]
# é‡è¦ä½æ‰€ã®è¡Œ
masters_rows = []
header_row = ws[1]
# 2) エクセルファイルを１行ãšã¤èªã¿è¾¼ã¿ï¼ˆï¼’行目ã‹ã‚‰ï¼‰ã€
for row in ws.iter_rows(min_row=2):
# マークã®ä»˜ã„ã¦ã„ã‚‹è¡Œã ã‘をリストã«å…¥ã‚Œã¦ãŠã
if row[2].value == "〇":
masters_rows.append(row)
masters_rows.insert(0,header_row)
# 3) æ–°è¦ã‚·ãƒ¼ãƒˆã‚’作æˆã™ã‚‹
ws2 = wb.create_sheet(title="é‡è¦ä½æ‰€")
# 4) æ–°è¦ã‚·ãƒ¼ãƒˆã«ãƒªã‚¹ãƒˆã«å…¥ã‚Œã¦ãŠã„ãŸè¡Œã‚’転記ã™ã‚‹
for master_row in masters_rows:
ws2.append([r.value for r in master_row])
# ３列目削除
ws2.delete_cols(3)
wb.save("sample.xlsx")
wb.remove(ws)
# 5) エクセルファイルをä¿å˜ã™ã‚‹
wb.save("é‡è¦ä½æ‰€.xlsx")
import pyautogui as pg
import time
import pyperclip
x,y=pg.locateCenterOnScreen('./picture_for_gui/yuubinn.png',confidence=0.1)
for i in range(10):
if i == 0:
pg.click(1223,1064,duration=0.5)
pg.moveTo(x,y,duration=1)
pg.press('down')
pg.hotkey('ctrl','c')
time.sleep(1)
pg.click(1305,1045,duration=0.5)
pg.click()
time.sleep(1)
pg.hotkey('return')
pg.typewrite('yuubinnbangou;\n')
pg.hotkey('ctrl','v')
pg.click(1223,1064,duration=0.5)
pg.press('tab')
pg.hotkey('ctrl','c')
pg.click(1305,1045,duration=0.5)
pg.hotkey('return')
pg.typewrite('jyuusyo;\n')
pg.hotkey('ctrl','v')
continue
pg.click(1223,1064,duration=0.5)
pg.click()
pg.hotkey('ctrl','left')
pg.press('down')
pg.hotkey('ctrl','c')
time.sleep(1)
pg.click(1305,1045,duration=0.5)
pg.click()
time.sleep(1)
pg.hotkey('return')
pg.typewrite('yuubinnbangou;\n')
pg.hotkey('ctrl','v')
pg.click(1223,1064,duration=0.5)
pg.press('tab')
pg.hotkey('ctrl','c')
pg.click(1305,1045,duration=0.5)
pg.hotkey('return')
pg.typewrite('jyuusyo;\n')
pg.hotkey('ctrl','v')
import os
import pathlib
import shutil
# 「Untitled.htmlã€ã¨ã„ã†ã‚ˆã†ãªãƒ•ã‚¡ã‚¤ãƒ«å+æ‹¡å¼µåã®ãƒªã‚¹ãƒˆç”¨
file_list = []
# after_file_list = []
# . ãŒå«ã¾ã‚Œã‚‹è€…ã™ã¹ã¦ã‚’抽出
for file in os.listdir("."):
# ファイルã‹ã©ã†ã‹ã‚’判定ã—ã€ãƒ•ã‚©ãƒ«ãƒ€ç‰ã‚’除外
is_file = os.path.isfile(file)
# ã“ã®pyファイル自身ã§ãªã„ã‹
# jupyter notebookã®å ´åˆã€ã‚¨ãƒ©ãƒ¼ã«ãªã‚‹ã®ã§ã€ç›´æŽ¥ãƒ•ã‚¡ã‚¤ãƒ«å入力
not_this_file = os.path.basename(__file__) != file
if is_file and not_this_file:
file_list.append(file)
# after_file_list.append(after_file_name)
current_dir = os.getcwd()
for target_file in file_list:
# æ‹¡å¼µåを抽出
target_ext = target_file.split(".")[-1]
# æ‹¡å¼µåãŒä»˜ã„ãŸæ–°ã—ã„フォルダパスを作æˆ
new_folder_path = os.path.join(current_dir,target_ext)
# ç¾åœ¨ã®ãƒ•ã‚¡ã‚¤ãƒ«ãƒ‘スを作æˆ
current_file_path = os.path.join(current_dir,target_file)
# æ–°ã—ã„ファイルパスを作æˆ
new_file_path = os.path.join(new_folder_path,target_file)
# æ–°ã—ãæ‹¡å¼µååã®ãƒ•ã‚©ãƒ«ãƒ€ã‚’作æˆã€‚
os.makedirs(new_folder_path,exist_ok=True)
# ファイルを移動。（既å˜ã®ãƒ•ã‚¡ã‚¤ãƒ«ãŒã‚ã£ã¦ã‚‚エラーã«ãªã‚‰ãªã„よã†ã«ã€çµ¶å¯¾ãƒ‘スã§è¨˜è¿°ï¼‰
shutil.move(current_file_path, new_file_path)
import os
import csv
import time
csv_file = 'filelist.csv'
date_format = '%Y/%m/%d %H:%M:%S'
file_list = []
for file in os.listdir("."):
# ファイルã‹ã©ã†ã‹
is_file = os.path.isfile(file)
# ã“ã®pyファイル自身ã§ãªã„ã‹
not_py_file = os.path.basename(__file__) != file
# リストCSVファイルã§ãªã„ã‹
not_csv_file = csv_file != file
if is_file and not_py_file and not_csv_file:
# ファイル作æˆæ™‚刻
time_crt = time.strftime(date_format,
time.localtime(os.path.getctime(file)))
# ファイル更新時刻
time_mod = time.strftime(date_format,
time.localtime(os.path.getmtime(file)))
file_list.append([file, time_crt, time_mod])
with open(csv_file, "w", newline="") as f:
csv_writer = csv.writer(f)
for r in file_list:
csv_writer.writerow(r)
def main():
import re
import glob
import os
import shutil
# åŒãƒ•ã‚©ãƒ«ãƒ€å†…ã®htmlファイルåã‚’å–å¾—
file_name = glob.glob('*.html')[0]
# 対象ファイルã®çµ¶å¯¾ãƒ‘スをå–å¾—
path = os.path.join(os.getcwd(),file_name)
# beforeフォルダã®çµ¶å¯¾ãƒ‘スをå–å¾—
before = os.path.join(os.getcwd(),"before")
# afterフォルダã®çµ¶å¯¾ãƒ‘スをå–å¾—
after = os.path.join(os.getcwd(),"after")
# フォルダã®æ–°è¦ä½œæˆï¼ˆæ—¢ã«ã‚ã‚‹å ´åˆã¯ä½œã‚‰ãªã„）
if not os.path.exists(before):
os.makedirs(before)
if not os.path.exists(after):
os.makedirs(after)
s = open('./'+file_name, 'r+',encoding="utf-16")
data_lines = s.read()
x=re.findall(r'[1-9]{1,4}.?[0-9]{0,8}[K,M]',data_lines)
def km_change(text):
if "K" in text:
changed = format(float(text.replace("K","0"))*1000, '.2f')
elif "M" in text:
changed = format(float(text.replace("M","0"))*1000000, '.2f')
return changed
for i in x:
data_lines=data_lines.replace(i,km_change(i))
# afterフォルダã¸ã®çµ¶å¯¾ãƒ‘スをå–å¾—
changed_file=os.path.join(after,file_name)
# beforeフォルダã¸ã®çµ¶å¯¾ãƒ‘スをå–å¾—
before_file=os.path.join(before,file_name)
with open(changed_file, mode="w", encoding="utf-16") as f:
f.write(data_lines)
s.close()
# 元ファイルをbeforeフォルダã¸ç§»å‹•
shutil.move(path, before_file)
if __name__=='__main__':
main()
class Demo:
def __init__(self):
self.a = 10
self.b = 20
def get_total_of_a_b:
total = self.a + self.b
return total
import pytest
import logging
import inspect
def test_inspect():
caller = inspect.stack()[1]
logging.info(f"\nThis is caller[3]: {caller[3]}")
def foo():
caller = inspect.stack()[1]
logging.info(f"\nThis is caller[3] inside function: {caller[3]}")
for item in caller:
logging.info(f"\nThis is caller item: {item}")
foo()
# Generator function
def generator(count):
i = 0
while i < count:
yield i
i += 1
def test_generator():
for value in generator(4):
print("\nGenerated value :", value)
pass
# Example demonstrates usage of function arguments default values
def foo(filename='testid', flag = True, number = None):
pdf_file = filename + ".pdf"
print(f'\n Filename = {pdf_file}, Flag = {flag}, number = {number}')
if __name__ == '__main__':
foo()
foo("readme", False, 4)
# to enable logging add to pytest.ini the following:
# [pytest]
#log_cli = 1
# log_level = INFO
# log_cli_level = INFO
# log_cli_format = %(asctime)s %(levelname)s %(message)s
# log_cli_date_format = %H:%M:%S
import pytest
import logging
# Example 1
def test_node_id(request):
node = request.node.nodeid
logging.info(f"\nThis is node: {node}")
module_name = request.module.__name__
logging.info(f"\nThis is module name: {module_name}")
function_name = request.function.__name__
logging.info(f"\nThis is function name: {function_name}")
fspath = request.fspath
logging.info(f"\nThis is fspath : {fspath}")
# Example 2
def test_func_node_id(request):
req = request
def foo(r):
node = r.node.nodeid
logging.info(f"
This is function node: {node}")
foo(req)
# Option 1: we have to specify 'sys'
import sys
if len(sys.argv) == 1:
print("No arguments specified")
print("This is the name of the script:", sys.argv[0] )
# Option 2
from sys import argv
if len(argv) == 1:
print("No arguments specified")
print("This is the name of the script:", argv[0] )
myfile = open('hello.txt', 'w')
myfile.write('Hello world')
myfile.close()
# The eval() method parses the expression passed to this method
# and runs python expression (code) within the program.
x = 1
print(eval('x + 1'))
# Asterisk turns parameter into tuple reference
def average(*nums):
result = sum(nums)/len(nums)
return result
# Example 1
x = average(10,20,30)
print('Example 1(pack): ',x)
# Example 2
x = average(10,20,30,40,50)
print('Example 2(pack): ', x)
# Asterisk unpacks tuple before sending to the function
# Example 3
mytuple = (10,20,30)
x = average(*mytuple)
print('Example 3(unpack): ', x)
def my_func():
return 1,2
x,y = my_func()
print(x)
print(y)
mylist = [900, 20, 300, 5, 90]
mylist.sort()
for x in mylist:
print(x)
mytuple = (10,20,30,45,60,70)
for x in mytuple[0:3]:
print(x)
print(============)
# iterate through first 2 numbers
for x in mytuple[:2]:
print(x)
print(============)
# iterate through last (6-4)=2 numbers
for x in mytuple[4:]:
print(x)
print(============)
mystring= "abcdefghijkl"
# iterate through string symbols starting fron 2nd, skip every 2 symbols
for x in mystring[2::2]:
print(x)
for a in range(1,11):
print("a is ", a)
# In Python, the name of the class refers to the class instance. Consider:
class A: pass
class B: pass
class C: pass
lst = [A, B, C]
# instantiate second class
b_instance = lst[1]()
print(b_instance)
import datetime
now = datetime.datetime.now()
print(f'{now:%Y-%m-%d %H:%M}')
# The example displays a formatted current datetime. The datetime format specifiers follow the : character.
# This is the output.
2019-05-11 22:39
# page object of Dashboard page. SitePAge - parent class
class SiteDashboardPage(SitePage):
PAGE_TITLE = (By.CLASS_NAME, 'page-title')
def __init__(self, browser):
SitePage.__init__(self, browser)
self.page_title = self.browser.find_element(*self.PAGE_TITLE).text
# yaml file used for account
- sitename: testcomp
email: test@outlook.com
pass: 111
role: admin
name: admin
- sitename: testcomp
email: mvsubmit@gmail.com
pass: 111
role: edit
name: user1
- sitename: testcomp
email: test2@outlook.com
pass: 11
role: edit
name: user2
# convert.py
# read yaml file into faccounts
faccounts = yaml.load(file, Loader=yaml.FullLoader)
# Convert list of dictionaries to nested dictionary so that we can select any value by user name and key nam
account = {account['name']: account for account in faccounts}
return account
# Deafult scope=function
@pytest.fixture
def browser():
# Initialize Chrome driver
driver = Chrome()
# Wait implicitly for elements to be ready before attempting interactions
driver.implicitly_wait(10)
# Return the driver object at the end of setup
yield driver
# For cleanup, quit the driver
driver.quit()
>>> name = "Eric Idle"
>>> f"{to_lowercase(name)} is funny."
'eric idle is funny.'
>>> f"{name.lower()} is funny."
'eric idle is funny.'
>>> F"Hello, {name}. You are {age}."
'Hello, Eric. You are 74.'
# Different ways to test multiple
# flags at once in Python
x, y, z = 0, 1, 0
if x == 1 or y == 1 or z == 1:
print('passed')
if 1 in (x, y, z):
print('passed')
# These only test for truthiness:
if x or y or z:
print('passed')
if any((x, y, z)):
print('passed')
# The get() method on dicts
# and its "default" argument
name_for_userid = {
382: "Alice",
590: "Bob",
951: "Dilbert",
}
def greeting(userid):
return "Hi %s!" % name_for_userid.get(userid, "there")
>>> greeting(382)
"Hi Alice!"
>>> greeting(333333)
"Hi there!"
''' When "get()" is called it checks if the given key exists in the dict.
If it does exist, the value for that key is returned.
If it does not exist then the value of the default argument is returned instead.'''
# Using namedtuple is way shorter than
# defining a class manually:
>>> from collections import namedtuple
>>> Car = namedtuple('Car', 'color mileage')
# Our new "Car" class works as expected:
>>> my_car = Car('red', 3812.4)
>>> my_car.color
'red'
>>> my_car.mileage
3812.4
# We get a nice string repr for free:
>>> my_car
Car(color='red' , mileage=3812.4)
# Like tuples, namedtuples are immutable:
>>> my_car.color = 'blue'
AttributeError: "can't set attribute"
# The standard string repr for dicts is hard to read:
>>> my_mapping = {'a': 23, 'b': 42, 'c': 0xc0ffee}
>>> my_mapping
{'b': 42, 'c': 12648430. 'a': 23} # 😞
# The "json" module can do a much better job:
>>> import json
>>> print(json.dumps(my_mapping, indent=4, sort_keys=True))
{
"a": 23,
"b": 42,
"c": 12648430
}
# Note this only works with dicts containing
# primitive types (check out the "pprint" module):
>>> json.dumps({all: 'yup'})
TypeError: keys must be a string
def myfunc(x, y, z):
print(x, y, z)
tuple_vec = (1, 0, 1)
dict_vec = {'x': 1, 'y': 0, 'z': 1}
>>> myfunc(*tuple_vec)
1, 0, 1
>>> myfunc(**dict_vec)
1, 0, 1
>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))',
number=10000)
0.3412662749997253
>>> timeit.timeit('"-".join([str(n) for n in range(100)])',
number=10000)
0.2996307989997149
>>> timeit.timeit('"-".join(map(str, range(100)))',
number=10000)
0.24581470699922647
# Opiton one
del df['column_name']
# The best way to do this in pandas is to use drop:
df = df.drop('column_name', 1)
# where 1 is the axis number (0 for rows and 1 for columns.) To delete the column without having to reassign df you can do:
df.drop('column_name', axis=1, inplace=True)
# Finally, to drop by column number instead of by column label, try this to delete, e.g. the 1st, 2nd and 4th columns:
df = df.drop(df.columns[[0, 1, 3]], axis=1) # df.columns is zero-based pd.Index this is called drop by index
# Another way is:
columns = ['Col1', 'Col2', ...]
df.drop(columns, inplace=True, axis=1)
new_df = pd.concat([df1, df2, df3, df4, df5])
#ore
new_df = pd.concat([df1, df2, df3, df4, df5], ignore_index=True)
if df.empty:
print('DataFrame is empty!')
# renove all single character for text
text = "t is a c test for removing multiple spaces"
document =' '.join( [w for w in text.split() if len(w)>1] )
print(document)
# remove numbers from string
s = '12abcd405'
result = ''.join([i for i in s if not i.isdigit()])
# remove all single characters
# replace all single chars,char
import re
text = "That is a test for removing multiple spaces"
document = re.sub(r's+[a-zA-Z]s+', ' ', text)
print(document)
# Remove all the special characters
# replace all character exept A-Z a-z
import re
text = "That is a # ; '' 2 45 6 ?/..,,, test for removing multiple spaces"
document = re.sub(r'W', ' ', text)
print(document) # as we can see this regex expresion do not remove numbers
# Substituting multiple spaces with single space
# replace multiple spaces with one space
# delete spaces
# spaces delete
# tabs replace with one space
# tow ore more spaces betwen words
import re
text = "That is a test for removing multiple spaces"
document = re.sub(r's+', ' ', text, flags=re.I)
print(document)
if word in mystring:
print ('success')
# or
if 'seek' in 'those who seek shall find':
print('Success!')
print("Enter 'x' for exit."):
hexdec =input("Enter any number in Hexadecimal Format: "):
if hexadec == 'x':
exit():
else:
dec=int(hexdec,16):
print(hexdec,"in Binary ="bin(dec)):
k=1
for i in range(0,5):
for j in range(0,k):
print("* ",end=" ")
k=k+2
print()
for i in range (0,5):
for j in range (0,i+1):
print("* ",end="")
print()
from tkinter import Tk,Menu,filedialog,END,messagebox
import tkinter.scrolledtext as ScrolledText
#Global File Name
filename = 'Untitled.txt'
#root for main window
root = Tk(className = " Text Editor Noob")
root.iconbitmap(r'icon.ico')
root.columnconfigure(0, weight=1)
root.rowconfigure(0, weight=1)
textArea = ScrolledText.ScrolledText(root,width=100, height =80)
#FUNCTIONS
#Open file function
def openFile():
file =filedialog.askopenfile(parent=root,title="Please Select a file to open",filetypes=(("Text File","*.txt"),("All Files","*")))
if file != None:
contents = file.read()
textArea.insert('1.0',contents)
file.close()
#Save as File function
def fileSaveAs():
file = filedialog.asksaveasfile(mode="w",defaultextension=".txt")
if file != None:
#slice of the last character from get,as an extra return (enter) is added
data = textArea.get('1.0',END+'-1c')
file.write(data)
file.close()
#Exit Function
def quitroot():
if messagebox.askyesno("Quit Text Editor Noob","Are you sure you want to quit?Because Biswas will mind if you quit X0X0"):
root.destroy()
#About function
def About():
label = messagebox.showinfo("About TextEditor Noob","An alternative notepad made with the help of Python and Developed By Biswas Sampad Satpathy")
#Menu options
menu = Menu(root)
root.config(menu=menu)
#top Menu
fileMenu = Menu(menu)
menu.add_cascade(label=" File",menu = fileMenu)
#sub menus
fileMenu.add_command(label="New")
fileMenu.add_command(label="Open",command = openFile)
fileMenu.add_command(label="Save As",command = fileSaveAs)
fileMenu.add_command(label="Print")
fileMenu.add_separator()
fileMenu.add_command(label="Close",command = quitroot)
#top menu
helpMenu = Menu(menu)
menu.add_cascade(label="Help",menu=helpMenu)
helpMenu.add_command(label="Help")
#top menu
aboutMenu = Menu(menu)
menu.add_cascade(label="About",command=About)
textArea.pack()
#keep window open
root.mainloop()
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
view_data = df1.drop(["timestamp","user_email","user_name"],axis=1)
movie_df = pd.merge(df2, view_data, on="movie_id")
movie_grouped = movie_df.groupby(['movie_name','movie_id']).agg({'no_of_views': 'count'}).reset_index()
grouped_sum = movie_grouped['no_of_views'].sum()
movie_grouped['percentage'] = movie_grouped['no_of_views'].div(grouped_sum)*100
movie_final = pd.DataFrame(movie_grouped)
count = pd.DataFrame(movie_final)
final_out = pd.merge(count, view_data, on="movie_id")
final_up =final_out.drop_duplicates(subset='movie_id', keep='first', inplace=False)
final = final_up.drop(["no_of_views_x","no_of_views_y","percentage"],axis=1)
# converting it to csv with store id
final_csv = final.to_csv('public/csv/'+str(studio_id)+'.csv')
# opening the exported csv file to save to mongodb
f = open('public/csv/'+ str(studio_id) +'.csv','rU')
#db URI
col = connect_db(server).recomendations
#reading csv
reader = csv.DictReader(f)
#askign desired header
fieldnames=("movie_name","movie_id","user_id","customer_id","store_id")
# loop to dismantle the dictionary as per the
if(mode == 1):
coly = connect_db(server).recomendations.delete_many({"customer_id":str(studio_id)})
else:
coly = connect_db(server).recomendations.delete_many({"store_id":str(studio_id)})
# colx = connect_db(server).recomendations.delete_many({"store_id_x":"101"})
for each in reader:
row={}
for field in fieldnames:
row[field] = each[field]
col.insert(row)
# cleaning the dataframes
df1.iloc[0:0]
df2.iloc[0:0]
#deleting the csv after exporting to database
# os.remove('public/csv/'+str(studio_id)+'.csv')
print('Training Done !!')
server = request.GET.get('server_info','production')
count = request.GET.get('limit_count')
user_id = request.GET.get('user_id')
customer_id = request.GET.get('alie_customer_id',None)
studio_id = request.GET.get('studio_id',None)
print(count)
print(user_id)
print(customer_id)
print(studio_id)
conda create --name myclone --clone base
virtualenv venv -p python3
pip install -r requirements.txt
Discussions
Articles
JSON Viewer
Dev Profile
More